1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1 (at) gmail.com> 5 // Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud (at) inria.fr> 6 // 7 // This Source Code Form is subject to the terms of the Mozilla 8 // Public License v. 2.0. If a copy of the MPL was not distributed 9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 11 #ifndef EIGEN_FORWARDDECLARATIONS_H 12 #define EIGEN_FORWARDDECLARATIONS_H 13 14 namespace Eigen { 15 namespace internal { 16 17 template<typename T> struct traits; 18 19 // here we say once and for all that traits<const T> == traits<T> 20 // When constness must affect traits, it has to be constness on template parameters on which T itself depends. 21 // For example, traits<Map<const T> > != traits<Map<T> >, but 22 // traits<const Map<T> > == traits<Map<T> > 23 template<typename T> struct traits<const T> : traits<T> {}; 24 25 template<typename Derived> struct has_direct_access 26 { 27 enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 }; 28 }; 29 30 template<typename Derived> struct accessors_level 31 { 32 enum { has_direct_access = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0, 33 has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0, 34 value = has_direct_access ? (has_write_access ? DirectWriteAccessors : DirectAccessors) 35 : (has_write_access ? WriteAccessors : ReadOnlyAccessors) 36 }; 37 }; 38 39 } // end namespace internal 40 41 template<typename T> struct NumTraits; 42 43 template<typename Derived> struct EigenBase; 44 template<typename Derived> class DenseBase; 45 template<typename Derived> class PlainObjectBase; 46 47 48 template<typename Derived, 49 int Level = internal::accessors_level<Derived>::value > 50 class DenseCoeffsBase; 51 52 template<typename _Scalar, int _Rows, int _Cols, 53 int _Options = AutoAlign | 54 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==4 55 // workaround a bug in at least gcc 3.4.6 56 // the innermost ?: ternary operator is misparsed. We write it slightly 57 // differently and this makes gcc 3.4.6 happy, but it's ugly. 58 // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined 59 // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor) 60 ( (_Rows==1 && _Cols!=1) ? RowMajor 61 : !(_Cols==1 && _Rows!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION 62 : ColMajor ), 63 #else 64 ( (_Rows==1 && _Cols!=1) ? RowMajor 65 : (_Cols==1 && _Rows!=1) ? ColMajor 66 : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ), 67 #endif 68 int _MaxRows = _Rows, 69 int _MaxCols = _Cols 70 > class Matrix; 71 72 template<typename Derived> class MatrixBase; 73 template<typename Derived> class ArrayBase; 74 75 template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged; 76 template<typename ExpressionType, template <typename> class StorageBase > class NoAlias; 77 template<typename ExpressionType> class NestByValue; 78 template<typename ExpressionType> class ForceAlignedAccess; 79 template<typename ExpressionType> class SwapWrapper; 80 81 template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false> class Block; 82 83 template<typename MatrixType, int Size=Dynamic> class VectorBlock; 84 template<typename MatrixType> class Transpose; 85 template<typename MatrixType> class Conjugate; 86 template<typename NullaryOp, typename MatrixType> class CwiseNullaryOp; 87 template<typename UnaryOp, typename MatrixType> class CwiseUnaryOp; 88 template<typename ViewOp, typename MatrixType> class CwiseUnaryView; 89 template<typename BinaryOp, typename Lhs, typename Rhs> class CwiseBinaryOp; 90 template<typename BinOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp; 91 template<typename Derived, typename Lhs, typename Rhs> class ProductBase; 92 template<typename Lhs, typename Rhs, int Mode> class GeneralProduct; 93 template<typename Lhs, typename Rhs, int NestingFlags> class CoeffBasedProduct; 94 95 template<typename Derived> class DiagonalBase; 96 template<typename _DiagonalVectorType> class DiagonalWrapper; 97 template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix; 98 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct; 99 template<typename MatrixType, int Index = 0> class Diagonal; 100 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix; 101 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions; 102 template<typename Derived> class PermutationBase; 103 template<typename Derived> class TranspositionsBase; 104 template<typename _IndicesType> class PermutationWrapper; 105 template<typename _IndicesType> class TranspositionsWrapper; 106 107 template<typename Derived, 108 int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors 109 > class MapBase; 110 template<int InnerStrideAtCompileTime, int OuterStrideAtCompileTime> class Stride; 111 template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map; 112 113 template<typename Derived> class TriangularBase; 114 template<typename MatrixType, unsigned int Mode> class TriangularView; 115 template<typename MatrixType, unsigned int Mode> class SelfAdjointView; 116 template<typename MatrixType> class SparseView; 117 template<typename ExpressionType> class WithFormat; 118 template<typename MatrixType> struct CommaInitializer; 119 template<typename Derived> class ReturnByValue; 120 template<typename ExpressionType> class ArrayWrapper; 121 template<typename ExpressionType> class MatrixWrapper; 122 123 namespace internal { 124 template<typename DecompositionType, typename Rhs> struct solve_retval_base; 125 template<typename DecompositionType, typename Rhs> struct solve_retval; 126 template<typename DecompositionType> struct kernel_retval_base; 127 template<typename DecompositionType> struct kernel_retval; 128 template<typename DecompositionType> struct image_retval_base; 129 template<typename DecompositionType> struct image_retval; 130 } // end namespace internal 131 132 namespace internal { 133 template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix; 134 } 135 136 namespace internal { 137 template<typename Lhs, typename Rhs> struct product_type; 138 } 139 140 template<typename Lhs, typename Rhs, 141 int ProductType = internal::product_type<Lhs,Rhs>::value> 142 struct ProductReturnType; 143 144 // this is a workaround for sun CC 145 template<typename Lhs, typename Rhs> struct LazyProductReturnType; 146 147 namespace internal { 148 149 // Provides scalar/packet-wise product and product with accumulation 150 // with optional conjugation of the arguments. 151 template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper; 152 153 template<typename Scalar> struct scalar_sum_op; 154 template<typename Scalar> struct scalar_difference_op; 155 template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op; 156 template<typename Scalar> struct scalar_opposite_op; 157 template<typename Scalar> struct scalar_conjugate_op; 158 template<typename Scalar> struct scalar_real_op; 159 template<typename Scalar> struct scalar_imag_op; 160 template<typename Scalar> struct scalar_abs_op; 161 template<typename Scalar> struct scalar_abs2_op; 162 template<typename Scalar> struct scalar_sqrt_op; 163 template<typename Scalar> struct scalar_exp_op; 164 template<typename Scalar> struct scalar_log_op; 165 template<typename Scalar> struct scalar_cos_op; 166 template<typename Scalar> struct scalar_sin_op; 167 template<typename Scalar> struct scalar_acos_op; 168 template<typename Scalar> struct scalar_asin_op; 169 template<typename Scalar> struct scalar_tan_op; 170 template<typename Scalar> struct scalar_pow_op; 171 template<typename Scalar> struct scalar_inverse_op; 172 template<typename Scalar> struct scalar_square_op; 173 template<typename Scalar> struct scalar_cube_op; 174 template<typename Scalar, typename NewType> struct scalar_cast_op; 175 template<typename Scalar> struct scalar_multiple_op; 176 template<typename Scalar> struct scalar_quotient1_op; 177 template<typename Scalar> struct scalar_min_op; 178 template<typename Scalar> struct scalar_max_op; 179 template<typename Scalar> struct scalar_random_op; 180 template<typename Scalar> struct scalar_add_op; 181 template<typename Scalar> struct scalar_constant_op; 182 template<typename Scalar> struct scalar_identity_op; 183 184 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op; 185 template<typename LhsScalar,typename RhsScalar> struct scalar_multiple2_op; 186 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op; 187 188 } // end namespace internal 189 190 struct IOFormat; 191 192 // Array module 193 template<typename _Scalar, int _Rows, int _Cols, 194 int _Options = AutoAlign | 195 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==4 196 // workaround a bug in at least gcc 3.4.6 197 // the innermost ?: ternary operator is misparsed. We write it slightly 198 // differently and this makes gcc 3.4.6 happy, but it's ugly. 199 // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined 200 // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor) 201 ( (_Rows==1 && _Cols!=1) ? RowMajor 202 : !(_Cols==1 && _Rows!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION 203 : ColMajor ), 204 #else 205 ( (_Rows==1 && _Cols!=1) ? RowMajor 206 : (_Cols==1 && _Rows!=1) ? ColMajor 207 : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ), 208 #endif 209 int _MaxRows = _Rows, int _MaxCols = _Cols> class Array; 210 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select; 211 template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr; 212 template<typename ExpressionType, int Direction> class VectorwiseOp; 213 template<typename MatrixType,int RowFactor,int ColFactor> class Replicate; 214 template<typename MatrixType, int Direction = BothDirections> class Reverse; 215 216 template<typename MatrixType> class FullPivLU; 217 template<typename MatrixType> class PartialPivLU; 218 namespace internal { 219 template<typename MatrixType> struct inverse_impl; 220 } 221 template<typename MatrixType> class HouseholderQR; 222 template<typename MatrixType> class ColPivHouseholderQR; 223 template<typename MatrixType> class FullPivHouseholderQR; 224 template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD; 225 template<typename MatrixType, int UpLo = Lower> class LLT; 226 template<typename MatrixType, int UpLo = Lower> class LDLT; 227 template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence; 228 template<typename Scalar> class JacobiRotation; 229 230 // Geometry module: 231 template<typename Derived, int _Dim> class RotationBase; 232 template<typename Lhs, typename Rhs> class Cross; 233 template<typename Derived> class QuaternionBase; 234 template<typename Scalar> class Rotation2D; 235 template<typename Scalar> class AngleAxis; 236 template<typename Scalar,int Dim> class Translation; 237 238 #ifdef EIGEN2_SUPPORT 239 template<typename Derived, int _Dim> class eigen2_RotationBase; 240 template<typename Lhs, typename Rhs> class eigen2_Cross; 241 template<typename Scalar> class eigen2_Quaternion; 242 template<typename Scalar> class eigen2_Rotation2D; 243 template<typename Scalar> class eigen2_AngleAxis; 244 template<typename Scalar,int Dim> class eigen2_Transform; 245 template <typename _Scalar, int _AmbientDim> class eigen2_ParametrizedLine; 246 template <typename _Scalar, int _AmbientDim> class eigen2_Hyperplane; 247 template<typename Scalar,int Dim> class eigen2_Translation; 248 template<typename Scalar,int Dim> class eigen2_Scaling; 249 #endif 250 251 #if EIGEN2_SUPPORT_STAGE < STAGE20_RESOLVE_API_CONFLICTS 252 template<typename Scalar> class Quaternion; 253 template<typename Scalar,int Dim> class Transform; 254 template <typename _Scalar, int _AmbientDim> class ParametrizedLine; 255 template <typename _Scalar, int _AmbientDim> class Hyperplane; 256 template<typename Scalar,int Dim> class Scaling; 257 #endif 258 259 #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS 260 template<typename Scalar, int Options = AutoAlign> class Quaternion; 261 template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform; 262 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine; 263 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane; 264 template<typename Scalar> class UniformScaling; 265 template<typename MatrixType,int Direction> class Homogeneous; 266 #endif 267 268 // MatrixFunctions module 269 template<typename Derived> struct MatrixExponentialReturnValue; 270 template<typename Derived> class MatrixFunctionReturnValue; 271 template<typename Derived> class MatrixSquareRootReturnValue; 272 template<typename Derived> class MatrixLogarithmReturnValue; 273 template<typename Derived> class MatrixPowerReturnValue; 274 template<typename Derived, typename Lhs, typename Rhs> class MatrixPowerProduct; 275 276 namespace internal { 277 template <typename Scalar> 278 struct stem_function 279 { 280 typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar; 281 typedef ComplexScalar type(ComplexScalar, int); 282 }; 283 } 284 285 286 #ifdef EIGEN2_SUPPORT 287 template<typename ExpressionType> class Cwise; 288 template<typename MatrixType> class Minor; 289 template<typename MatrixType> class LU; 290 template<typename MatrixType> class QR; 291 template<typename MatrixType> class SVD; 292 namespace internal { 293 template<typename MatrixType, unsigned int Mode> struct eigen2_part_return_type; 294 } 295 #endif 296 297 } // end namespace Eigen 298 299 #endif // EIGEN_FORWARDDECLARATIONS_H 300
