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