ForwardDeclarations.h
Go to the documentation of this file.
00001 // This file is part of Eigen, a lightweight C++ template library
00002 // for linear algebra.
00003 //
00004 // Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
00005 // Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
00006 //
00007 // This Source Code Form is subject to the terms of the Mozilla
00008 // Public License v. 2.0. If a copy of the MPL was not distributed
00009 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
00010 
00011 #ifndef EIGEN_FORWARDDECLARATIONS_H
00012 #define EIGEN_FORWARDDECLARATIONS_H
00013 
00014 namespace Eigen {
00015 namespace internal {
00016 
00017 template<typename T> struct traits;
00018 
00019 // here we say once and for all that traits<const T> == traits<T>
00020 // When constness must affect traits, it has to be constness on template parameters on which T itself depends.
00021 // For example, traits<Map<const T> > != traits<Map<T> >, but
00022 //              traits<const Map<T> > == traits<Map<T> >
00023 template<typename T> struct traits<const T> : traits<T> {};
00024 
00025 template<typename Derived> struct has_direct_access
00026 {
00027   enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
00028 };
00029 
00030 template<typename Derived> struct accessors_level
00031 {
00032   enum { has_direct_access = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0,
00033          has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0,
00034          value = has_direct_access ? (has_write_access ? DirectWriteAccessors : DirectAccessors)
00035                                    : (has_write_access ? WriteAccessors       : ReadOnlyAccessors)
00036   };
00037 };
00038 
00039 } // end namespace internal
00040 
00041 template<typename T> struct NumTraits;
00042 
00043 template<typename Derived> struct EigenBase;
00044 template<typename Derived> class DenseBase;
00045 template<typename Derived> class PlainObjectBase;
00046 
00047 
00048 template<typename Derived,
00049          int Level = internal::accessors_level<Derived>::value >
00050 class DenseCoeffsBase;
00051 
00052 template<typename _Scalar, int _Rows, int _Cols,
00053          int _Options = AutoAlign |
00054 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==4
00055     // workaround a bug in at least gcc 3.4.6
00056     // the innermost ?: ternary operator is misparsed. We write it slightly
00057     // differently and this makes gcc 3.4.6 happy, but it's ugly.
00058     // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
00059     // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
00060                           ( (_Rows==1 && _Cols!=1) ? RowMajor
00061                           : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
00062                           : ColMajor ),
00063 #else
00064                           ( (_Rows==1 && _Cols!=1) ? RowMajor
00065                           : (_Cols==1 && _Rows!=1) ? ColMajor
00066                           : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
00067 #endif
00068          int _MaxRows = _Rows,
00069          int _MaxCols = _Cols
00070 > class Matrix;
00071 
00072 template<typename Derived> class MatrixBase;
00073 template<typename Derived> class ArrayBase;
00074 
00075 template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
00076 template<typename ExpressionType, template <typename> class StorageBase > class NoAlias;
00077 template<typename ExpressionType> class NestByValue;
00078 template<typename ExpressionType> class ForceAlignedAccess;
00079 template<typename ExpressionType> class SwapWrapper;
00080 
00081 template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
00082          bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class Block;
00083 
00084 template<typename MatrixType, int Size=Dynamic> class VectorBlock;
00085 template<typename MatrixType> class Transpose;
00086 template<typename MatrixType> class Conjugate;
00087 template<typename NullaryOp, typename MatrixType>         class CwiseNullaryOp;
00088 template<typename UnaryOp,   typename MatrixType>         class CwiseUnaryOp;
00089 template<typename ViewOp,    typename MatrixType>         class CwiseUnaryView;
00090 template<typename BinaryOp,  typename Lhs, typename Rhs>  class CwiseBinaryOp;
00091 template<typename BinOp,     typename Lhs, typename Rhs>  class SelfCwiseBinaryOp;
00092 template<typename Derived,   typename Lhs, typename Rhs>  class ProductBase;
00093 template<typename Lhs, typename Rhs, int Mode>            class GeneralProduct;
00094 template<typename Lhs, typename Rhs, int NestingFlags>    class CoeffBasedProduct;
00095 
00096 template<typename Derived> class DiagonalBase;
00097 template<typename _DiagonalVectorType> class DiagonalWrapper;
00098 template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
00099 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
00100 template<typename MatrixType, int Index = 0> class Diagonal;
00101 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
00102 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
00103 template<typename Derived> class PermutationBase;
00104 template<typename Derived> class TranspositionsBase;
00105 template<typename _IndicesType> class PermutationWrapper;
00106 template<typename _IndicesType> class TranspositionsWrapper;
00107 
00108 template<typename Derived,
00109          int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
00110 > class MapBase;
00111 template<int InnerStrideAtCompileTime, int OuterStrideAtCompileTime> class Stride;
00112 template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
00113 
00114 template<typename Derived> class TriangularBase;
00115 template<typename MatrixType, unsigned int Mode> class TriangularView;
00116 template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
00117 template<typename MatrixType> class SparseView;
00118 template<typename ExpressionType> class WithFormat;
00119 template<typename MatrixType> struct CommaInitializer;
00120 template<typename Derived> class ReturnByValue;
00121 template<typename ExpressionType> class ArrayWrapper;
00122 template<typename ExpressionType> class MatrixWrapper;
00123 
00124 namespace internal {
00125 template<typename DecompositionType, typename Rhs> struct solve_retval_base;
00126 template<typename DecompositionType, typename Rhs> struct solve_retval;
00127 template<typename DecompositionType> struct kernel_retval_base;
00128 template<typename DecompositionType> struct kernel_retval;
00129 template<typename DecompositionType> struct image_retval_base;
00130 template<typename DecompositionType> struct image_retval;
00131 } // end namespace internal
00132 
00133 namespace internal {
00134 template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
00135 }
00136 
00137 namespace internal {
00138 template<typename Lhs, typename Rhs> struct product_type;
00139 }
00140 
00141 template<typename Lhs, typename Rhs,
00142          int ProductType = internal::product_type<Lhs,Rhs>::value>
00143 struct ProductReturnType;
00144 
00145 // this is a workaround for sun CC
00146 template<typename Lhs, typename Rhs> struct LazyProductReturnType;
00147 
00148 namespace internal {
00149 
00150 // Provides scalar/packet-wise product and product with accumulation
00151 // with optional conjugation of the arguments.
00152 template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
00153 
00154 template<typename Scalar> struct scalar_sum_op;
00155 template<typename Scalar> struct scalar_difference_op;
00156 template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op;
00157 template<typename Scalar> struct scalar_quotient_op;
00158 template<typename Scalar> struct scalar_opposite_op;
00159 template<typename Scalar> struct scalar_conjugate_op;
00160 template<typename Scalar> struct scalar_real_op;
00161 template<typename Scalar> struct scalar_imag_op;
00162 template<typename Scalar> struct scalar_abs_op;
00163 template<typename Scalar> struct scalar_abs2_op;
00164 template<typename Scalar> struct scalar_sqrt_op;
00165 template<typename Scalar> struct scalar_exp_op;
00166 template<typename Scalar> struct scalar_log_op;
00167 template<typename Scalar> struct scalar_cos_op;
00168 template<typename Scalar> struct scalar_sin_op;
00169 template<typename Scalar> struct scalar_acos_op;
00170 template<typename Scalar> struct scalar_asin_op;
00171 template<typename Scalar> struct scalar_tan_op;
00172 template<typename Scalar> struct scalar_pow_op;
00173 template<typename Scalar> struct scalar_inverse_op;
00174 template<typename Scalar> struct scalar_square_op;
00175 template<typename Scalar> struct scalar_cube_op;
00176 template<typename Scalar, typename NewType> struct scalar_cast_op;
00177 template<typename Scalar> struct scalar_multiple_op;
00178 template<typename Scalar> struct scalar_quotient1_op;
00179 template<typename Scalar> struct scalar_min_op;
00180 template<typename Scalar> struct scalar_max_op;
00181 template<typename Scalar> struct scalar_random_op;
00182 template<typename Scalar> struct scalar_add_op;
00183 template<typename Scalar> struct scalar_constant_op;
00184 template<typename Scalar> struct scalar_identity_op;
00185 
00186 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
00187 template<typename LhsScalar,typename RhsScalar> struct scalar_multiple2_op;
00188 
00189 } // end namespace internal
00190 
00191 struct IOFormat;
00192 
00193 // Array module
00194 template<typename _Scalar, int _Rows, int _Cols,
00195          int _Options = AutoAlign |
00196 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==4
00197     // workaround a bug in at least gcc 3.4.6
00198     // the innermost ?: ternary operator is misparsed. We write it slightly
00199     // differently and this makes gcc 3.4.6 happy, but it's ugly.
00200     // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
00201     // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
00202                           ( (_Rows==1 && _Cols!=1) ? RowMajor
00203                           : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
00204                           : ColMajor ),
00205 #else
00206                           ( (_Rows==1 && _Cols!=1) ? RowMajor
00207                           : (_Cols==1 && _Rows!=1) ? ColMajor
00208                           : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
00209 #endif
00210          int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
00211 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
00212 template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
00213 template<typename ExpressionType, int Direction> class VectorwiseOp;
00214 template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
00215 template<typename MatrixType, int Direction = BothDirections> class Reverse;
00216 
00217 template<typename MatrixType> class FullPivLU;
00218 template<typename MatrixType> class PartialPivLU;
00219 namespace internal {
00220 template<typename MatrixType> struct inverse_impl;
00221 }
00222 template<typename MatrixType> class HouseholderQR;
00223 template<typename MatrixType> class ColPivHouseholderQR;
00224 template<typename MatrixType> class FullPivHouseholderQR;
00225 template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
00226 template<typename MatrixType, int UpLo = Lower> class LLT;
00227 template<typename MatrixType, int UpLo = Lower> class LDLT;
00228 template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
00229 template<typename Scalar>     class JacobiRotation;
00230 
00231 // Geometry module:
00232 template<typename Derived, int _Dim> class RotationBase;
00233 template<typename Lhs, typename Rhs> class Cross;
00234 template<typename Derived> class QuaternionBase;
00235 template<typename Scalar> class Rotation2D;
00236 template<typename Scalar> class AngleAxis;
00237 template<typename Scalar,int Dim> class Translation;
00238 
00239 #ifdef EIGEN2_SUPPORT
00240 template<typename Derived, int _Dim> class eigen2_RotationBase;
00241 template<typename Lhs, typename Rhs> class eigen2_Cross;
00242 template<typename Scalar> class eigen2_Quaternion;
00243 template<typename Scalar> class eigen2_Rotation2D;
00244 template<typename Scalar> class eigen2_AngleAxis;
00245 template<typename Scalar,int Dim> class eigen2_Transform;
00246 template <typename _Scalar, int _AmbientDim> class eigen2_ParametrizedLine;
00247 template <typename _Scalar, int _AmbientDim> class eigen2_Hyperplane;
00248 template<typename Scalar,int Dim> class eigen2_Translation;
00249 template<typename Scalar,int Dim> class eigen2_Scaling;
00250 #endif
00251 
00252 #if EIGEN2_SUPPORT_STAGE < STAGE20_RESOLVE_API_CONFLICTS
00253 template<typename Scalar> class Quaternion;
00254 template<typename Scalar,int Dim> class Transform;
00255 template <typename _Scalar, int _AmbientDim> class ParametrizedLine;
00256 template <typename _Scalar, int _AmbientDim> class Hyperplane;
00257 template<typename Scalar,int Dim> class Scaling;
00258 #endif
00259 
00260 #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS
00261 template<typename Scalar, int Options = AutoAlign> class Quaternion;
00262 template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
00263 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
00264 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
00265 template<typename Scalar> class UniformScaling;
00266 template<typename MatrixType,int Direction> class Homogeneous;
00267 #endif
00268 
00269 // MatrixFunctions module
00270 template<typename Derived> struct MatrixExponentialReturnValue;
00271 template<typename Derived> class MatrixFunctionReturnValue;
00272 template<typename Derived> class MatrixSquareRootReturnValue;
00273 template<typename Derived> class MatrixLogarithmReturnValue;
00274 
00275 namespace internal {
00276 template <typename Scalar>
00277 struct stem_function
00278 {
00279   typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
00280   typedef ComplexScalar type(ComplexScalar, int);
00281 };
00282 }
00283 
00284 
00285 #ifdef EIGEN2_SUPPORT
00286 template<typename ExpressionType> class Cwise;
00287 template<typename MatrixType> class Minor;
00288 template<typename MatrixType> class LU;
00289 template<typename MatrixType> class QR;
00290 template<typename MatrixType> class SVD;
00291 namespace internal {
00292 template<typename MatrixType, unsigned int Mode> struct eigen2_part_return_type;
00293 }
00294 #endif
00295 
00296 } // end namespace Eigen
00297 
00298 #endif // EIGEN_FORWARDDECLARATIONS_H


win_eigen
Author(s): Daniel Stonier
autogenerated on Wed Sep 16 2015 07:10:31