Main MRPT website > C++ reference
MRPT logo

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 internal {
00030 
00031 template<typename T> struct traits;
00032 
00033 // here we say once and for all that traits<const T> == traits<T>
00034 // When constness must affect traits, it has to be constness on template parameters on which T itself depends.
00035 // For example, traits<Map<const T> > != traits<Map<T> >, but
00036 //              traits<const Map<T> > == traits<Map<T> >
00037 template<typename T> struct traits<const T> : traits<T> {};
00038 
00039 template<typename Derived> struct has_direct_access
00040 {
00041   enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
00042 };
00043 
00044 template<typename Derived> struct accessors_level
00045 {
00046   enum { has_direct_access = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0,
00047          has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0,
00048          value = has_direct_access ? (has_write_access ? DirectWriteAccessors : DirectAccessors)
00049                                    : (has_write_access ? WriteAccessors       : ReadOnlyAccessors)
00050   };
00051 };
00052 
00053 } // end namespace internal
00054 
00055 template<typename T> struct NumTraits;
00056 
00057 template<typename Derived> struct EigenBase;
00058 template<typename Derived> class DenseBase;
00059 template<typename Derived> class PlainObjectBase;
00060 
00061 
00062 template<typename Derived,
00063          int Level = internal::accessors_level<Derived>::value >
00064 class DenseCoeffsBase;
00065 
00066 template<typename _Scalar, int _Rows, int _Cols,
00067          int _Options = AutoAlign |
00068                           ( (_Rows==1 && _Cols!=1) ? RowMajor
00069                           : (_Cols==1 && _Rows!=1) ? ColMajor
00070                           : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
00071          int _MaxRows = _Rows,
00072          int _MaxCols = _Cols
00073 > class Matrix;
00074 
00075 template<typename Derived> class MatrixBase;
00076 template<typename Derived> class ArrayBase;
00077 
00078 template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
00079 template<typename ExpressionType, template <typename> class StorageBase > class NoAlias;
00080 template<typename ExpressionType> class NestByValue;
00081 template<typename ExpressionType> class ForceAlignedAccess;
00082 template<typename ExpressionType> class SwapWrapper;
00083 
00084 template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false,
00085          bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class Block;
00086 
00087 template<typename MatrixType, int Size=Dynamic> class VectorBlock;
00088 template<typename MatrixType> class Transpose;
00089 template<typename MatrixType> class Conjugate;
00090 template<typename NullaryOp, typename MatrixType>         class CwiseNullaryOp;
00091 template<typename UnaryOp,   typename MatrixType>         class CwiseUnaryOp;
00092 template<typename ViewOp,    typename MatrixType>         class CwiseUnaryView;
00093 template<typename BinaryOp,  typename Lhs, typename Rhs>  class CwiseBinaryOp;
00094 template<typename BinOp,     typename Lhs, typename Rhs>  class SelfCwiseBinaryOp;
00095 template<typename Derived,   typename Lhs, typename Rhs>  class ProductBase;
00096 template<typename Lhs, typename Rhs, int Mode>            class GeneralProduct;
00097 template<typename Lhs, typename Rhs, int NestingFlags>    class CoeffBasedProduct;
00098 
00099 template<typename Derived> class DiagonalBase;
00100 template<typename _DiagonalVectorType> class DiagonalWrapper;
00101 template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
00102 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
00103 template<typename MatrixType, int Index = 0> class Diagonal;
00104 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime> class PermutationMatrix;
00105 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime> class Transpositions;
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 
00122 namespace internal {
00123 template<typename DecompositionType, typename Rhs> struct solve_retval_base;
00124 template<typename DecompositionType, typename Rhs> struct solve_retval;
00125 template<typename DecompositionType> struct kernel_retval_base;
00126 template<typename DecompositionType> struct kernel_retval;
00127 template<typename DecompositionType> struct image_retval_base;
00128 template<typename DecompositionType> struct image_retval;
00129 } // end namespace internal
00130 
00131 namespace internal {
00132 template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
00133 }
00134 
00135 namespace internal {
00136 template<typename Lhs, typename Rhs> struct product_type;
00137 }
00138 
00139 template<typename Lhs, typename Rhs,
00140          int ProductType = internal::product_type<Lhs,Rhs>::value>
00141 struct ProductReturnType;
00142 
00143 // this is a workaround for sun CC
00144 template<typename Lhs, typename Rhs> struct LazyProductReturnType;
00145 
00146 namespace internal {
00147 
00148 // Provides scalar/packet-wise product and product with accumulation
00149 // with optional conjugation of the arguments.
00150 template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
00151 
00152 template<typename Scalar> struct scalar_sum_op;
00153 template<typename Scalar> struct scalar_difference_op;
00154 template<typename Scalar> struct scalar_conj_product_op;
00155 template<typename Scalar> struct scalar_quotient_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_pow_op;
00168 template<typename Scalar> struct scalar_inverse_op;
00169 template<typename Scalar> struct scalar_square_op;
00170 template<typename Scalar> struct scalar_cube_op;
00171 template<typename Scalar, typename NewType> struct scalar_cast_op;
00172 template<typename Scalar> struct scalar_multiple_op;
00173 template<typename Scalar> struct scalar_quotient1_op;
00174 template<typename Scalar> struct scalar_min_op;
00175 template<typename Scalar> struct scalar_max_op;
00176 template<typename Scalar> struct scalar_random_op;
00177 template<typename Scalar> struct scalar_add_op;
00178 template<typename Scalar> struct scalar_constant_op;
00179 template<typename Scalar> struct scalar_identity_op;
00180 
00181 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
00182 template<typename LhsScalar,typename RhsScalar> struct scalar_multiple2_op;
00183 
00184 } // end namespace internal
00185 
00186 struct IOFormat;
00187 
00188 // Array module
00189 template<typename _Scalar, int _Rows, int _Cols,
00190          int _Options = AutoAlign |
00191                           ( (_Rows==1 && _Cols!=1) ? RowMajor
00192                           : (_Cols==1 && _Rows!=1) ? ColMajor
00193                           : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
00194          int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
00195 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
00196 template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
00197 template<typename ExpressionType, int Direction> class VectorwiseOp;
00198 template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
00199 template<typename MatrixType, int Direction = BothDirections> class Reverse;
00200 
00201 template<typename MatrixType> class FullPivLU;
00202 template<typename MatrixType> class PartialPivLU;
00203 namespace internal {
00204 template<typename MatrixType> struct inverse_impl;
00205 }
00206 template<typename MatrixType> class HouseholderQR;
00207 template<typename MatrixType> class ColPivHouseholderQR;
00208 template<typename MatrixType> class FullPivHouseholderQR;
00209 template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
00210 template<typename MatrixType, int UpLo = Lower> class LLT;
00211 template<typename MatrixType, int UpLo = Lower> class LDLT;
00212 template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
00213 template<typename Scalar>     class JacobiRotation;
00214 
00215 // Geometry module:
00216 template<typename Derived, int _Dim> class RotationBase;
00217 template<typename Lhs, typename Rhs> class Cross;
00218 template<typename Derived> class QuaternionBase;
00219 template<typename Scalar> class Quaternion;
00220 template<typename Scalar> class Rotation2D;
00221 template<typename Scalar> class AngleAxis;
00222 template<typename Scalar,int Dim,int Mode> class Transform;
00223 template <typename _Scalar, int _AmbientDim> class ParametrizedLine;
00224 template <typename _Scalar, int _AmbientDim> class Hyperplane;
00225 template<typename Scalar,int Dim> class Translation;
00226 template<typename Scalar> class UniformScaling;
00227 template<typename MatrixType,int Direction> class Homogeneous;
00228 
00229 // MatrixFunctions module
00230 template<typename Derived> struct MatrixExponentialReturnValue;
00231 template<typename Derived> class MatrixFunctionReturnValue;
00232 
00233 namespace internal {
00234 template <typename Scalar>
00235 struct stem_function
00236 {
00237   typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
00238   typedef ComplexScalar type(ComplexScalar, int);
00239 };
00240 }
00241 
00242 
00243 #ifdef EIGEN2_SUPPORT
00244 template<typename ExpressionType> class Cwise;
00245 template<typename MatrixType> class Minor;
00246 #endif
00247 
00248 #endif // EIGEN_FORWARDDECLARATIONS_H



Page generated by Doxygen 1.7.3 for MRPT 0.9.4 SVN: at Sat Mar 26 06:16:28 UTC 2011