ForwardDeclarations.h
Go to the documentation of this file.
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@gmail.com>
5 // Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@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 {
33  has_write_access = (traits<Derived>::Flags & LvalueBit) ? 1 : 0,
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,
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
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,
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,
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 
156 template< typename T,
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
163 }
164 
165 template<typename Lhs, typename Rhs,
166  int ProductType = internal::product_type<Lhs,Rhs>::value>
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>
294 {
296  typedef ComplexScalar type(ComplexScalar, int);
297 };
298 }
299 
300 } // end namespace Eigen
301 
302 #endif // EIGEN_FORWARDDECLARATIONS_H
Generic expression of a matrix where all coefficients are defined by a functor.
Robust Cholesky decomposition of a matrix with pivoting.
Definition: LDLT.h:50
std::complex< typename NumTraits< Scalar >::Real > ComplexScalar
Enforce aligned packet loads and stores regardless of what is requested.
Expression of the product of two arbitrary matrices or vectors.
Definition: Product.h:71
Expression of a mathematical vector or matrix as an array object.
Definition: ArrayWrapper.h:42
Householder rank-revealing QR decomposition of a matrix with full pivoting.
Pseudo expression providing an operator = assuming no aliasing.
Definition: NoAlias.h:31
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:94
Proxy for the matrix square root of some matrix (expression).
Base class for triangular part in a matrix.
Expression of the transpose of a matrix.
Definition: Transpose.h:52
const unsigned int DirectAccessBit
Definition: Constants.h:150
const unsigned int LvalueBit
Definition: Constants.h:139
Represents a rectangular matrix with a banded storage.
Definition: BandMatrix.h:199
Represents a diagonal matrix with its storage.
LU decomposition of a matrix with partial pivoting, and related features.
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
Holds strides information for Map.
Definition: Stride.h:44
Rotation given by a cosine-sine pair.
Generic expression of a partially reduxed matrix.
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:150
Pseudo expression providing partial reduction operations.
Complete orthogonal decomposition (COD) of a matrix.
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
Proxy for the matrix function of some matrix (expression).
Proxy for the matrix power of some matrix (expression).
An axis aligned box.
Base class for permutations.
Helper class used by the comma initializer operator.
Sequence of Householder reflections acting on subspaces with decreasing size.
Represents a translation transformation.
Expression of the inverse of another expression.
Definition: Inverse.h:43
Permutation matrix.
Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector.
Expression of an array as a mathematical vector or matrix.
Definition: ArrayBase.h:15
Expression of a fixed-size or dynamic-size sub-vector.
Generic expression where a coefficient-wise binary operator is applied to two expressions.
Definition: CwiseBinaryOp.h:77
Base class of any sparse matrices or sparse expressions.
Householder rank-revealing QR decomposition of a matrix with column-pivoting.
Standard Cholesky decomposition (LL^T) of a matrix and associated features.
Definition: LLT.h:56
Convenience specialization of Stride to specify only an inner stride See class Map for some examples...
Definition: Stride.h:90
Eigen::Triplet< double > T
Generic expression where a coefficient-wise ternary operator is applied to two expressions.
Expression of the multiple replication of a matrix or vector.
Definition: Replicate.h:61
Common base class for compact rotation representations.
Expression of a selfadjoint matrix from a triangular part of a dense matrix.
Expression of a dense or sparse matrix with zero or too small values removed.
Base class for all 1D and 2D array, and related expressions.
Definition: ArrayBase.h:39
Class to view a vector of integers as a permutation matrix.
Base class for quaternion expressions.
Expression which must be nested by value.
Definition: NestByValue.h:34
class Bidiagonal Divide and Conquer SVD
A matrix or vector expression mapping an existing expression.
Definition: Ref.h:192
mp::number< mp::cpp_dec_float< 100 >, mp::et_on > Real
ComplexScalar type(ComplexScalar, int)
Represents a rotation/orientation in a 2 dimensional space.
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:103
DenseIndex ret
Definition: level1_impl.h:59
The quaternion class used to represent 3D orientations and rotations.
LU decomposition of a matrix with complete pivoting, and related features.
storage_kind_to_shape< typename traits< T >::StorageKind >::Shape Shape
Householder QR decomposition of a matrix.
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:45
Two-sided Jacobi SVD decomposition of a rectangular matrix.
Expression of a triangular part in a matrix.
Expression of a diagonal matrix.
Proxy for the matrix exponential of some matrix (expression).
Expression of a diagonal/subdiagonal/superdiagonal in a matrix.
Definition: Diagonal.h:63
Pseudo expression representing a solving operation.
Definition: Solve.h:62
Generic expression where a coefficient-wise unary operator is applied to an expression.
Definition: CwiseUnaryOp.h:55
The matrix class, also used for vectors and row-vectors.
Pseudo expression providing matrix output with given format.
Definition: IO.h:94
Convenience specialization of Stride to specify only an outer stride See class Map for some examples...
Definition: Stride.h:101
Expression of the reverse of a vector or matrix.
Definition: Reverse.h:63
A base class for matrix decomposition and solvers.
Definition: SolverBase.h:41
Proxy for the matrix power of some matrix (expression).
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48
A parametrized line.
Stores a set of parameters controlling the way matrices are printed.
Definition: IO.h:50
Represents a 3D rotation as a rotation angle around an arbitrary 3D axis.
Represents a sequence of transpositions (row/column interchange)
Represents an homogeneous transformation in a N dimensional space.
Proxy for the matrix logarithm of some matrix (expression).
Definition: pytypes.h:897
#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
Definition: Macros.h:332
Expression of one (or a set of) homogeneous vector(s)
Expression of a coefficient wise version of the C++ ternary operator ?:
Definition: Select.h:52
An InnerIterator allows to loop over the element of any matrix expression.
Definition: CoreIterators.h:33


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:42:04