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 template<typename T> struct evaluator_traits; 40 41 template< typename T> struct evaluator; 42 43 } // end namespace internal 44 45 template<typename T> struct NumTraits; 46 47 template<typename Derived> struct EigenBase; 48 template<typename Derived> class DenseBase; 49 template<typename Derived> class PlainObjectBase; 50 51 52 template<typename Derived, 53 int Level = internal::accessors_level<Derived>::value > 54 class DenseCoeffsBase; 55 56 template<typename _Scalar, int _Rows, int _Cols, 57 int _Options = AutoAlign | 58 #if EIGEN_GNUC_AT(3,4) 59 // workaround a bug in at least gcc 3.4.6 60 // the innermost ?: ternary operator is misparsed. We write it slightly 61 // differently and this makes gcc 3.4.6 happy, but it's ugly. 62 // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined 63 // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor) 64 ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor 65 : !(_Cols==1 && _Rows!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION 66 : Eigen::ColMajor ), 67 #else 68 ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor 69 : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor 70 : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ), 71 #endif 72 int _MaxRows = _Rows, 73 int _MaxCols = _Cols 74 > class Matrix; 75 76 template<typename Derived> class MatrixBase; 77 template<typename Derived> class ArrayBase; 78 79 template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged; 80 template<typename ExpressionType, template <typename> class StorageBase > class NoAlias; 81 template<typename ExpressionType> class NestByValue; 82 template<typename ExpressionType> class ForceAlignedAccess; 83 template<typename ExpressionType> class SwapWrapper; 84 85 template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false> class Block; 86 87 template<typename MatrixType, int Size=Dynamic> class VectorBlock; 88 template<typename MatrixType> class Transpose; 89 template<typename MatrixType> class Conjugate; 90 template<typename NullaryOp, typename MatrixType> class CwiseNullaryOp; 91 template<typename UnaryOp, typename MatrixType> class CwiseUnaryOp; 92 template<typename ViewOp, typename MatrixType> class CwiseUnaryView; 93 template<typename BinaryOp, typename Lhs, typename Rhs> class CwiseBinaryOp; 94 template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3> class CwiseTernaryOp; 95 template<typename Decomposition, typename Rhstype> class Solve; 96 template<typename XprType> class Inverse; 97 98 template<typename Lhs, typename Rhs, int Option = DefaultProduct> class Product; 99 100 template<typename Derived> class DiagonalBase; 101 template<typename _DiagonalVectorType> class DiagonalWrapper; 102 template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix; 103 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct; 104 template<typename MatrixType, int Index = 0> class Diagonal; 105 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix; 106 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions; 107 template<typename Derived> class PermutationBase; 108 template<typename Derived> class TranspositionsBase; 109 template<typename _IndicesType> class PermutationWrapper; 110 template<typename _IndicesType> class TranspositionsWrapper; 111 112 template<typename Derived, 113 int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors 114 > class MapBase; 115 template<int InnerStrideAtCompileTime, int OuterStrideAtCompileTime> class Stride; 116 template<int Value = Dynamic> class InnerStride; 117 template<int Value = Dynamic> class OuterStride; 118 template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map; 119 template<typename Derived> class RefBase; 120 template<typename PlainObjectType, int Options = 0, 121 typename StrideType = typename internal::conditional<PlainObjectType::IsVectorAtCompileTime,InnerStride<1>,OuterStride<> >::type > class Ref; 122 123 template<typename Derived> class TriangularBase; 124 template<typename MatrixType, unsigned int Mode> class TriangularView; 125 template<typename MatrixType, unsigned int Mode> class SelfAdjointView; 126 template<typename MatrixType> class SparseView; 127 template<typename ExpressionType> class WithFormat; 128 template<typename MatrixType> struct CommaInitializer; 129 template<typename Derived> class ReturnByValue; 130 template<typename ExpressionType> class ArrayWrapper; 131 template<typename ExpressionType> class MatrixWrapper; 132 template<typename Derived> class SolverBase; 133 template<typename XprType> class InnerIterator; 134 135 namespace internal { 136 template<typename DecompositionType> struct kernel_retval_base; 137 template<typename DecompositionType> struct kernel_retval; 138 template<typename DecompositionType> struct image_retval_base; 139 template<typename DecompositionType> struct image_retval; 140 } // end namespace internal 141 142 namespace internal { 143 template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix; 144 } 145 146 namespace internal { 147 template<typename Lhs, typename Rhs> struct product_type; 148 149 template<bool> struct EnableIf; 150 151 /** \internal 152 * \class product_evaluator 153 * Products need their own evaluator with more template arguments allowing for 154 * easier partial template specializations. 155 */ 156 template< typename T, 157 int ProductTag = internal::product_type<typename T::Lhs,typename T::Rhs>::ret, 158 typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape, 159 typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape, 160 typename LhsScalar = typename traits<typename T::Lhs>::Scalar, 161 typename RhsScalar = typename traits<typename T::Rhs>::Scalar 162 > struct product_evaluator; 163 } 164 165 template<typename Lhs, typename Rhs, 166 int ProductType = internal::product_type<Lhs,Rhs>::value> 167 struct ProductReturnType; 168 169 // this is a workaround for sun CC 170 template<typename Lhs, typename Rhs> struct LazyProductReturnType; 171 172 namespace internal { 173 174 // Provides scalar/packet-wise product and product with accumulation 175 // with optional conjugation of the arguments. 176 template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper; 177 178 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_sum_op; 179 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_difference_op; 180 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_conj_product_op; 181 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_min_op; 182 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_max_op; 183 template<typename Scalar> struct scalar_opposite_op; 184 template<typename Scalar> struct scalar_conjugate_op; 185 template<typename Scalar> struct scalar_real_op; 186 template<typename Scalar> struct scalar_imag_op; 187 template<typename Scalar> struct scalar_abs_op; 188 template<typename Scalar> struct scalar_abs2_op; 189 template<typename Scalar> struct scalar_sqrt_op; 190 template<typename Scalar> struct scalar_rsqrt_op; 191 template<typename Scalar> struct scalar_exp_op; 192 template<typename Scalar> struct scalar_log_op; 193 template<typename Scalar> struct scalar_cos_op; 194 template<typename Scalar> struct scalar_sin_op; 195 template<typename Scalar> struct scalar_acos_op; 196 template<typename Scalar> struct scalar_asin_op; 197 template<typename Scalar> struct scalar_tan_op; 198 template<typename Scalar> struct scalar_inverse_op; 199 template<typename Scalar> struct scalar_square_op; 200 template<typename Scalar> struct scalar_cube_op; 201 template<typename Scalar, typename NewType> struct scalar_cast_op; 202 template<typename Scalar> struct scalar_random_op; 203 template<typename Scalar> struct scalar_constant_op; 204 template<typename Scalar> struct scalar_identity_op; 205 template<typename Scalar,bool iscpx> struct scalar_sign_op; 206 template<typename Scalar,typename ScalarExponent> struct scalar_pow_op; 207 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_hypot_op; 208 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op; 209 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op; 210 211 // SpecialFunctions module 212 template<typename Scalar> struct scalar_lgamma_op; 213 template<typename Scalar> struct scalar_digamma_op; 214 template<typename Scalar> struct scalar_erf_op; 215 template<typename Scalar> struct scalar_erfc_op; 216 template<typename Scalar> struct scalar_igamma_op; 217 template<typename Scalar> struct scalar_igammac_op; 218 template<typename Scalar> struct scalar_zeta_op; 219 template<typename Scalar> struct scalar_betainc_op; 220 221 } // end namespace internal 222 223 struct IOFormat; 224 225 // Array module 226 template<typename _Scalar, int _Rows, int _Cols, 227 int _Options = AutoAlign | 228 #if EIGEN_GNUC_AT(3,4) 229 // workaround a bug in at least gcc 3.4.6 230 // the innermost ?: ternary operator is misparsed. We write it slightly 231 // differently and this makes gcc 3.4.6 happy, but it's ugly. 232 // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined 233 // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor) 234 ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor 235 : !(_Cols==1 && _Rows!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION 236 : Eigen::ColMajor ), 237 #else 238 ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor 239 : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor 240 : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ), 241 #endif 242 int _MaxRows = _Rows, int _MaxCols = _Cols> class Array; 243 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select; 244 template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr; 245 template<typename ExpressionType, int Direction> class VectorwiseOp; 246 template<typename MatrixType,int RowFactor,int ColFactor> class Replicate; 247 template<typename MatrixType, int Direction = BothDirections> class Reverse; 248 249 template<typename MatrixType> class FullPivLU; 250 template<typename MatrixType> class PartialPivLU; 251 namespace internal { 252 template<typename MatrixType> struct inverse_impl; 253 } 254 template<typename MatrixType> class HouseholderQR; 255 template<typename MatrixType> class ColPivHouseholderQR; 256 template<typename MatrixType> class FullPivHouseholderQR; 257 template<typename MatrixType> class CompleteOrthogonalDecomposition; 258 template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD; 259 template<typename MatrixType> class BDCSVD; 260 template<typename MatrixType, int UpLo = Lower> class LLT; 261 template<typename MatrixType, int UpLo = Lower> class LDLT; 262 template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence; 263 template<typename Scalar> class JacobiRotation; 264 265 // Geometry module: 266 template<typename Derived, int _Dim> class RotationBase; 267 template<typename Lhs, typename Rhs> class Cross; 268 template<typename Derived> class QuaternionBase; 269 template<typename Scalar> class Rotation2D; 270 template<typename Scalar> class AngleAxis; 271 template<typename Scalar,int Dim> class Translation; 272 template<typename Scalar,int Dim> class AlignedBox; 273 template<typename Scalar, int Options = AutoAlign> class Quaternion; 274 template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform; 275 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine; 276 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane; 277 template<typename Scalar> class UniformScaling; 278 template<typename MatrixType,int Direction> class Homogeneous; 279 280 // Sparse module: 281 template<typename Derived> class SparseMatrixBase; 282 283 // MatrixFunctions module 284 template<typename Derived> struct MatrixExponentialReturnValue; 285 template<typename Derived> class MatrixFunctionReturnValue; 286 template<typename Derived> class MatrixSquareRootReturnValue; 287 template<typename Derived> class MatrixLogarithmReturnValue; 288 template<typename Derived> class MatrixPowerReturnValue; 289 template<typename Derived> class MatrixComplexPowerReturnValue; 290 291 namespace internal { 292 template <typename Scalar> 293 struct stem_function 294 { 295 typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar; 296 typedef ComplexScalar type(ComplexScalar, int); 297 }; 298 } 299 300 } // end namespace Eigen 301 302 #endif // EIGEN_FORWARDDECLARATIONS_H 303
