Core/util/ForwardDeclarations.h

0001 // This file is part of Eigen, a lightweight C++ template library
0002 // for linear algebra.
0003 //
0004 // Copyright (C) 2007-2010 Benoit Jacob <jacob.benoit.1@gmail.com>
0005 // Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
0006 //
0007 // This Source Code Form is subject to the terms of the Mozilla
0008 // Public License v. 2.0. If a copy of the MPL was not distributed
0009 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
0010
0011 #ifndef EIGEN_FORWARDDECLARATIONS_H
0012 #define EIGEN_FORWARDDECLARATIONS_H
0013
0014 namespace Eigen {
0015 namespace internal {
0016
0017 template<typename T> struct traits;
0018
0019 // here we say once and for all that traits<const T> == traits<T>
0020 // When constness must affect traits, it has to be constness on template parameters on which T itself depends.
0021 // For example, traits<Map<const T> > != traits<Map<T> >, but
0022 //              traits<const Map<T> > == traits<Map<T> >
0023 template<typename T> struct traits<const T> : traits<T> {};
0024
0025 template<typename Derived> struct has_direct_access
0026 {
0027   enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
0028 };
0029
0030 template<typename Derived> struct accessors_level
0031 {
0032   enum { has_direct_access = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0,
0033          has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0,
0034          value = has_direct_access ? (has_write_access ? DirectWriteAccessors : DirectAccessors)
0035                                    : (has_write_access ? WriteAccessors       : ReadOnlyAccessors)
0036   };
0037 };
0038
0039 template<typename T> struct evaluator_traits;
0040
0041 template< typename T> struct evaluator;
0042
0043 } // end namespace internal
0044
0045 template<typename T> struct NumTraits;
0046
0047 template<typename Derived> struct EigenBase;
0048 template<typename Derived> class DenseBase;
0049 template<typename Derived> class PlainObjectBase;
0050 template<typename Derived, int Level> class DenseCoeffsBase;
0051
0052 template<typename _Scalar, int _Rows, int _Cols,
0053          int _Options = AutoAlign |
0054 #if EIGEN_GNUC_AT(3,4)
0055     // workaround a bug in at least gcc 3.4.6
0056     // the innermost ?: ternary operator is misparsed. We write it slightly
0057     // differently and this makes gcc 3.4.6 happy, but it's ugly.
0058     // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
0059     // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
0060                           ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
0061                           : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
0062                           : Eigen::ColMajor ),
0063 #else
0064                           ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
0065                           : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
0066                           : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
0067 #endif
0068          int _MaxRows = _Rows,
0069          int _MaxCols = _Cols
0070 > class Matrix;
0071
0072 template<typename Derived> class MatrixBase;
0073 template<typename Derived> class ArrayBase;
0074
0075 template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
0076 template<typename ExpressionType, template <typename> class StorageBase > class NoAlias;
0077 template<typename ExpressionType> class NestByValue;
0078 template<typename ExpressionType> class ForceAlignedAccess;
0079 template<typename ExpressionType> class SwapWrapper;
0080
0081 template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false> class Block;
0082 template<typename XprType, typename RowIndices, typename ColIndices> class IndexedView;
0083 template<typename XprType, int Rows=Dynamic, int Cols=Dynamic, int Order=0> class Reshaped;
0084
0085 template<typename MatrixType, int Size=Dynamic> class VectorBlock;
0086 template<typename MatrixType> class Transpose;
0087 template<typename MatrixType> class Conjugate;
0088 template<typename NullaryOp, typename MatrixType>         class CwiseNullaryOp;
0089 template<typename UnaryOp,   typename MatrixType>         class CwiseUnaryOp;
0090 template<typename ViewOp,    typename MatrixType>         class CwiseUnaryView;
0091 template<typename BinaryOp,  typename Lhs, typename Rhs>  class CwiseBinaryOp;
0092 template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>  class CwiseTernaryOp;
0093 template<typename Decomposition, typename Rhstype>        class Solve;
0094 template<typename XprType>                                class Inverse;
0095
0096 template<typename Lhs, typename Rhs, int Option = DefaultProduct> class Product;
0097
0098 template<typename Derived> class DiagonalBase;
0099 template<typename _DiagonalVectorType> class DiagonalWrapper;
0100 template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
0101 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
0102 template<typename MatrixType, int Index = 0> class Diagonal;
0103 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
0104 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
0105 template<typename Derived> class PermutationBase;
0106 template<typename Derived> class TranspositionsBase;
0107 template<typename _IndicesType> class PermutationWrapper;
0108 template<typename _IndicesType> class TranspositionsWrapper;
0109
0110 template<typename Derived,
0111          int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
0112 > class MapBase;
0113 template<int OuterStrideAtCompileTime, int InnerStrideAtCompileTime> class Stride;
0114 template<int Value = Dynamic> class InnerStride;
0115 template<int Value = Dynamic> class OuterStride;
0116 template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
0117 template<typename Derived> class RefBase;
0118 template<typename PlainObjectType, int Options = 0,
0119          typename StrideType = typename internal::conditional<PlainObjectType::IsVectorAtCompileTime,InnerStride<1>,OuterStride<> >::type > class Ref;
0120
0121 template<typename Derived> class TriangularBase;
0122 template<typename MatrixType, unsigned int Mode> class TriangularView;
0123 template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
0124 template<typename MatrixType> class SparseView;
0125 template<typename ExpressionType> class WithFormat;
0126 template<typename MatrixType> struct CommaInitializer;
0127 template<typename Derived> class ReturnByValue;
0128 template<typename ExpressionType> class ArrayWrapper;
0129 template<typename ExpressionType> class MatrixWrapper;
0130 template<typename Derived> class SolverBase;
0131 template<typename XprType> class InnerIterator;
0132
0133 namespace internal {
0134 template<typename XprType> class generic_randaccess_stl_iterator;
0135 template<typename XprType> class pointer_based_stl_iterator;
0136 template<typename XprType, DirectionType Direction> class subvector_stl_iterator;
0137 template<typename XprType, DirectionType Direction> class subvector_stl_reverse_iterator;
0138 template<typename DecompositionType> struct kernel_retval_base;
0139 template<typename DecompositionType> struct kernel_retval;
0140 template<typename DecompositionType> struct image_retval_base;
0141 template<typename DecompositionType> struct image_retval;
0142 } // end namespace internal
0143
0144 namespace internal {
0145 template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
0146 }
0147
0148 namespace internal {
0149 template<typename Lhs, typename Rhs> struct product_type;
0150
0151 template<bool> struct EnableIf;
0152
0153 /** \internal
0154   * \class product_evaluator
0155   * Products need their own evaluator with more template arguments allowing for
0156   * easier partial template specializations.
0157   */
0158 template< typename T,
0159           int ProductTag = internal::product_type<typename T::Lhs,typename T::Rhs>::ret,
0160           typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape,
0161           typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape,
0162           typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
0163           typename RhsScalar = typename traits<typename T::Rhs>::Scalar
0164         > struct product_evaluator;
0165 }
0166
0167 template<typename Lhs, typename Rhs,
0168          int ProductType = internal::product_type<Lhs,Rhs>::value>
0169 struct ProductReturnType;
0170
0171 // this is a workaround for sun CC
0172 template<typename Lhs, typename Rhs> struct LazyProductReturnType;
0173
0174 namespace internal {
0175
0176 // Provides scalar/packet-wise product and product with accumulation
0177 // with optional conjugation of the arguments.
0178 template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
0179
0180 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_sum_op;
0181 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_difference_op;
0182 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_conj_product_op;
0183 template<typename LhsScalar,typename RhsScalar=LhsScalar, int NaNPropagation=PropagateFast> struct scalar_min_op;
0184 template<typename LhsScalar,typename RhsScalar=LhsScalar, int NaNPropagation=PropagateFast> struct scalar_max_op;
0185 template<typename Scalar> struct scalar_opposite_op;
0186 template<typename Scalar> struct scalar_conjugate_op;
0187 template<typename Scalar> struct scalar_real_op;
0188 template<typename Scalar> struct scalar_imag_op;
0189 template<typename Scalar> struct scalar_abs_op;
0190 template<typename Scalar> struct scalar_abs2_op;
0191 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_absolute_difference_op;
0192 template<typename Scalar> struct scalar_sqrt_op;
0193 template<typename Scalar> struct scalar_rsqrt_op;
0194 template<typename Scalar> struct scalar_exp_op;
0195 template<typename Scalar> struct scalar_log_op;
0196 template<typename Scalar> struct scalar_cos_op;
0197 template<typename Scalar> struct scalar_sin_op;
0198 template<typename Scalar> struct scalar_acos_op;
0199 template<typename Scalar> struct scalar_asin_op;
0200 template<typename Scalar> struct scalar_tan_op;
0201 template<typename Scalar> struct scalar_inverse_op;
0202 template<typename Scalar> struct scalar_square_op;
0203 template<typename Scalar> struct scalar_cube_op;
0204 template<typename Scalar, typename NewType> struct scalar_cast_op;
0205 template<typename Scalar> struct scalar_random_op;
0206 template<typename Scalar> struct scalar_constant_op;
0207 template<typename Scalar> struct scalar_identity_op;
0208 template<typename Scalar,bool is_complex, bool is_integer> struct scalar_sign_op;
0209 template<typename Scalar,typename ScalarExponent> struct scalar_pow_op;
0210 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_hypot_op;
0211 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
0212 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op;
0213
0214 // SpecialFunctions module
0215 template<typename Scalar> struct scalar_lgamma_op;
0216 template<typename Scalar> struct scalar_digamma_op;
0217 template<typename Scalar> struct scalar_erf_op;
0218 template<typename Scalar> struct scalar_erfc_op;
0219 template<typename Scalar> struct scalar_ndtri_op;
0220 template<typename Scalar> struct scalar_igamma_op;
0221 template<typename Scalar> struct scalar_igammac_op;
0222 template<typename Scalar> struct scalar_zeta_op;
0223 template<typename Scalar> struct scalar_betainc_op;
0224
0225 // Bessel functions in SpecialFunctions module
0226 template<typename Scalar> struct scalar_bessel_i0_op;
0227 template<typename Scalar> struct scalar_bessel_i0e_op;
0228 template<typename Scalar> struct scalar_bessel_i1_op;
0229 template<typename Scalar> struct scalar_bessel_i1e_op;
0230 template<typename Scalar> struct scalar_bessel_j0_op;
0231 template<typename Scalar> struct scalar_bessel_y0_op;
0232 template<typename Scalar> struct scalar_bessel_j1_op;
0233 template<typename Scalar> struct scalar_bessel_y1_op;
0234 template<typename Scalar> struct scalar_bessel_k0_op;
0235 template<typename Scalar> struct scalar_bessel_k0e_op;
0236 template<typename Scalar> struct scalar_bessel_k1_op;
0237 template<typename Scalar> struct scalar_bessel_k1e_op;
0238
0239
0240 } // end namespace internal
0241
0242 struct IOFormat;
0243
0244 // Array module
0245 template<typename _Scalar, int _Rows, int _Cols,
0246          int _Options = AutoAlign |
0247 #if EIGEN_GNUC_AT(3,4)
0248     // workaround a bug in at least gcc 3.4.6
0249     // the innermost ?: ternary operator is misparsed. We write it slightly
0250     // differently and this makes gcc 3.4.6 happy, but it's ugly.
0251     // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
0252     // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
0253                           ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
0254                           : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
0255                           : Eigen::ColMajor ),
0256 #else
0257                           ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
0258                           : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
0259                           : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
0260 #endif
0261          int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
0262 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
0263 template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
0264 template<typename ExpressionType, int Direction> class VectorwiseOp;
0265 template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
0266 template<typename MatrixType, int Direction = BothDirections> class Reverse;
0267
0268 template<typename MatrixType> class FullPivLU;
0269 template<typename MatrixType> class PartialPivLU;
0270 namespace internal {
0271 template<typename MatrixType> struct inverse_impl;
0272 }
0273 template<typename MatrixType> class HouseholderQR;
0274 template<typename MatrixType> class ColPivHouseholderQR;
0275 template<typename MatrixType> class FullPivHouseholderQR;
0276 template<typename MatrixType> class CompleteOrthogonalDecomposition;
0277 template<typename MatrixType> class SVDBase;
0278 template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
0279 template<typename MatrixType> class BDCSVD;
0280 template<typename MatrixType, int UpLo = Lower> class LLT;
0281 template<typename MatrixType, int UpLo = Lower> class LDLT;
0282 template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
0283 template<typename Scalar>     class JacobiRotation;
0284
0285 // Geometry module:
0286 template<typename Derived, int _Dim> class RotationBase;
0287 template<typename Lhs, typename Rhs> class Cross;
0288 template<typename Derived> class QuaternionBase;
0289 template<typename Scalar> class Rotation2D;
0290 template<typename Scalar> class AngleAxis;
0291 template<typename Scalar,int Dim> class Translation;
0292 template<typename Scalar,int Dim> class AlignedBox;
0293 template<typename Scalar, int Options = AutoAlign> class Quaternion;
0294 template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
0295 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
0296 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
0297 template<typename Scalar> class UniformScaling;
0298 template<typename MatrixType,int Direction> class Homogeneous;
0299
0300 // Sparse module:
0301 template<typename Derived> class SparseMatrixBase;
0302
0303 // MatrixFunctions module
0304 template<typename Derived> struct MatrixExponentialReturnValue;
0305 template<typename Derived> class MatrixFunctionReturnValue;
0306 template<typename Derived> class MatrixSquareRootReturnValue;
0307 template<typename Derived> class MatrixLogarithmReturnValue;
0308 template<typename Derived> class MatrixPowerReturnValue;
0309 template<typename Derived> class MatrixComplexPowerReturnValue;
0310
0311 namespace internal {
0312 template <typename Scalar>
0313 struct stem_function
0314 {
0315   typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
0316   typedef ComplexScalar type(ComplexScalar, int);
0317 };
0318 }
0319
0320 } // end namespace Eigen
0321
0322 #endif // EIGEN_FORWARDDECLARATIONS_H