Eigne Matrix Class Library
Dependents: Eigen_test Odometry_test AttitudeEstimation_usingTicker MPU9250_Quaternion_Binary_Serial ... more
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
Generated on Tue Jul 12 2022 17:46:53 by 1.7.2