ForwardDeclarations.h

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> class Block;
00082 
00083 template<typename MatrixType, int Size=Dynamic> class VectorBlock;
00084 template<typename MatrixType> class Transpose;
00085 template<typename MatrixType> class Conjugate;
00086 template<typename NullaryOp, typename MatrixType>         class CwiseNullaryOp;
00087 template<typename UnaryOp,   typename MatrixType>         class CwiseUnaryOp;
00088 template<typename ViewOp,    typename MatrixType>         class CwiseUnaryView;
00089 template<typename BinaryOp,  typename Lhs, typename Rhs>  class CwiseBinaryOp;
00090 template<typename BinOp,     typename Lhs, typename Rhs>  class SelfCwiseBinaryOp;
00091 template<typename Derived,   typename Lhs, typename Rhs>  class ProductBase;
00092 template<typename Lhs, typename Rhs, int Mode>            class GeneralProduct;
00093 template<typename Lhs, typename Rhs, int NestingFlags>    class CoeffBasedProduct;
00094 
00095 template<typename Derived> class DiagonalBase;
00096 template<typename _DiagonalVectorType> class DiagonalWrapper;
00097 template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
00098 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
00099 template<typename MatrixType, int Index = 0> class Diagonal;
00100 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
00101 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
00102 template<typename Derived> class PermutationBase;
00103 template<typename Derived> class TranspositionsBase;
00104 template<typename _IndicesType> class PermutationWrapper;
00105 template<typename _IndicesType> class TranspositionsWrapper;
00106 
00107 template<typename Derived,
00108          int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
00109 > class MapBase;
00110 template<int InnerStrideAtCompileTime, int OuterStrideAtCompileTime> class Stride;
00111 template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
00112 
00113 template<typename Derived> class TriangularBase;
00114 template<typename MatrixType, unsigned int Mode> class TriangularView;
00115 template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
00116 template<typename MatrixType> class SparseView;
00117 template<typename ExpressionType> class WithFormat;
00118 template<typename MatrixType> struct CommaInitializer;
00119 template<typename Derived> class ReturnByValue;
00120 template<typename ExpressionType> class ArrayWrapper;
00121 template<typename ExpressionType> class MatrixWrapper;
00122 
00123 namespace internal {
00124 template<typename DecompositionType, typename Rhs> struct solve_retval_base;
00125 template<typename DecompositionType, typename Rhs> struct solve_retval;
00126 template<typename DecompositionType> struct kernel_retval_base;
00127 template<typename DecompositionType> struct kernel_retval;
00128 template<typename DecompositionType> struct image_retval_base;
00129 template<typename DecompositionType> struct image_retval;
00130 } // end namespace internal
00131 
00132 namespace internal {
00133 template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
00134 }
00135 
00136 namespace internal {
00137 template<typename Lhs, typename Rhs> struct product_type;
00138 }
00139 
00140 template<typename Lhs, typename Rhs,
00141          int ProductType = internal::product_type<Lhs,Rhs>::value>
00142 struct ProductReturnType;
00143 
00144 // this is a workaround for sun CC
00145 template<typename Lhs, typename Rhs> struct LazyProductReturnType;
00146 
00147 namespace internal {
00148 
00149 // Provides scalar/packet-wise product and product with accumulation
00150 // with optional conjugation of the arguments.
00151 template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
00152 
00153 template<typename Scalar> struct scalar_sum_op;
00154 template<typename Scalar> struct scalar_difference_op;
00155 template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op;
00156 template<typename Scalar> struct scalar_opposite_op;
00157 template<typename Scalar> struct scalar_conjugate_op;
00158 template<typename Scalar> struct scalar_real_op;
00159 template<typename Scalar> struct scalar_imag_op;
00160 template<typename Scalar> struct scalar_abs_op;
00161 template<typename Scalar> struct scalar_abs2_op;
00162 template<typename Scalar> struct scalar_sqrt_op;
00163 template<typename Scalar> struct scalar_exp_op;
00164 template<typename Scalar> struct scalar_log_op;
00165 template<typename Scalar> struct scalar_cos_op;
00166 template<typename Scalar> struct scalar_sin_op;
00167 template<typename Scalar> struct scalar_acos_op;
00168 template<typename Scalar> struct scalar_asin_op;
00169 template<typename Scalar> struct scalar_tan_op;
00170 template<typename Scalar> struct scalar_pow_op;
00171 template<typename Scalar> struct scalar_inverse_op;
00172 template<typename Scalar> struct scalar_square_op;
00173 template<typename Scalar> struct scalar_cube_op;
00174 template<typename Scalar, typename NewType> struct scalar_cast_op;
00175 template<typename Scalar> struct scalar_multiple_op;
00176 template<typename Scalar> struct scalar_quotient1_op;
00177 template<typename Scalar> struct scalar_min_op;
00178 template<typename Scalar> struct scalar_max_op;
00179 template<typename Scalar> struct scalar_random_op;
00180 template<typename Scalar> struct scalar_add_op;
00181 template<typename Scalar> struct scalar_constant_op;
00182 template<typename Scalar> struct scalar_identity_op;
00183 
00184 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
00185 template<typename LhsScalar,typename RhsScalar> struct scalar_multiple2_op;
00186 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op;
00187 
00188 } // end namespace internal
00189 
00190 struct IOFormat;
00191 
00192 // Array module
00193 template<typename _Scalar, int _Rows, int _Cols,
00194          int _Options = AutoAlign |
00195 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==4
00196     // workaround a bug in at least gcc 3.4.6
00197     // the innermost ?: ternary operator is misparsed. We write it slightly
00198     // differently and this makes gcc 3.4.6 happy, but it's ugly.
00199     // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
00200     // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
00201                           ( (_Rows==1 && _Cols!=1) ? RowMajor
00202                           : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
00203                           : ColMajor ),
00204 #else
00205                           ( (_Rows==1 && _Cols!=1) ? RowMajor
00206                           : (_Cols==1 && _Rows!=1) ? ColMajor
00207                           : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
00208 #endif
00209          int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
00210 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
00211 template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
00212 template<typename ExpressionType, int Direction> class VectorwiseOp;
00213 template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
00214 template<typename MatrixType, int Direction = BothDirections> class Reverse;
00215 
00216 template<typename MatrixType> class FullPivLU;
00217 template<typename MatrixType> class PartialPivLU;
00218 namespace internal {
00219 template<typename MatrixType> struct inverse_impl;
00220 }
00221 template<typename MatrixType> class HouseholderQR;
00222 template<typename MatrixType> class ColPivHouseholderQR;
00223 template<typename MatrixType> class FullPivHouseholderQR;
00224 template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
00225 template<typename MatrixType, int UpLo = Lower> class LLT;
00226 template<typename MatrixType, int UpLo = Lower> class LDLT;
00227 template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
00228 template<typename Scalar>     class JacobiRotation;
00229 
00230 // Geometry module:
00231 template<typename Derived, int _Dim> class RotationBase;
00232 template<typename Lhs, typename Rhs> class Cross;
00233 template<typename Derived> class QuaternionBase;
00234 template<typename Scalar> class Rotation2D;
00235 template<typename Scalar> class AngleAxis;
00236 template<typename Scalar,int Dim> class Translation;
00237 
00238 // Sparse module:
00239 template<typename Derived> class SparseMatrixBase;
00240 
00241 #ifdef EIGEN2_SUPPORT
00242 template<typename Derived, int _Dim> class eigen2_RotationBase;
00243 template<typename Lhs, typename Rhs> class eigen2_Cross;
00244 template<typename Scalar> class eigen2_Quaternion;
00245 template<typename Scalar> class eigen2_Rotation2D;
00246 template<typename Scalar> class eigen2_AngleAxis;
00247 template<typename Scalar,int Dim> class eigen2_Transform;
00248 template <typename _Scalar, int _AmbientDim> class eigen2_ParametrizedLine;
00249 template <typename _Scalar, int _AmbientDim> class eigen2_Hyperplane;
00250 template<typename Scalar,int Dim> class eigen2_Translation;
00251 template<typename Scalar,int Dim> class eigen2_Scaling;
00252 #endif
00253 
00254 #if EIGEN2_SUPPORT_STAGE < STAGE20_RESOLVE_API_CONFLICTS
00255 template<typename Scalar> class Quaternion;
00256 template<typename Scalar,int Dim> class Transform;
00257 template <typename _Scalar, int _AmbientDim> class ParametrizedLine;
00258 template <typename _Scalar, int _AmbientDim> class Hyperplane;
00259 template<typename Scalar,int Dim> class Scaling ;
00260 #endif
00261 
00262 #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS
00263 template<typename Scalar, int Options = AutoAlign> class Quaternion;
00264 template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
00265 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
00266 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
00267 template<typename Scalar> class UniformScaling;
00268 template<typename MatrixType,int Direction> class Homogeneous;
00269 #endif
00270 
00271 // MatrixFunctions module
00272 template<typename Derived> struct MatrixExponentialReturnValue;
00273 template<typename Derived> class MatrixFunctionReturnValue;
00274 template<typename Derived> class MatrixSquareRootReturnValue;
00275 template<typename Derived> class MatrixLogarithmReturnValue;
00276 template<typename Derived> class MatrixPowerReturnValue;
00277 template<typename Derived, typename Lhs, typename Rhs> class MatrixPowerProduct;
00278 
00279 namespace internal {
00280 template <typename Scalar>
00281 struct stem_function
00282 {
00283   typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
00284   typedef ComplexScalar type(ComplexScalar, int);
00285 };
00286 }
00287 
00288 
00289 #ifdef EIGEN2_SUPPORT
00290 template<typename ExpressionType> class Cwise;
00291 template<typename MatrixType> class Minor;
00292 template<typename MatrixType> class LU;
00293 template<typename MatrixType> class QR;
00294 template<typename MatrixType> class SVD;
00295 namespace internal {
00296 template<typename MatrixType, unsigned int Mode> struct eigen2_part_return_type;
00297 }
00298 #endif
00299 
00300 } // end namespace Eigen
00301 
00302 #endif // EIGEN_FORWARDDECLARATIONS_H