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,
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,
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
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,
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>
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
Expression of the product of two general matrices or vectors.
Generic expression of a matrix where all coefficients are defined by a functor.
Robust Cholesky decomposition of a matrix with pivoting.
Definition: LDLT.h:45
std::complex< typename NumTraits< Scalar >::Real > ComplexScalar
Represents a possibly non uniform scaling transformation.
Base class for Map and Block expression with direct access.
Enforce aligned packet loads and stores regardless of what is requested.
USING_NAMESPACE_ACADO typedef TaylorVariable< Interval > T
Expression of a mathematical vector or matrix as an array object.
Definition: ArrayWrapper.h:36
Householder rank-revealing QR decomposition of a matrix with full pivoting.
Expression with modified flags.
Definition: Flagged.h:39
Definition: LU.h:16
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:104
Proxy for the matrix square root of some matrix (expression).
Expression of the transpose of a matrix.
Definition: Transpose.h:57
const unsigned int DirectAccessBit
const unsigned int LvalueBit
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.
iterative scaling algorithm to equilibrate rows and column norms in matrices
Definition: matrix.hpp:471
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:88
#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
Pseudo expression providing partial reduction operations.
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
Proxy for the matrix function of some matrix (expression).
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.
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.
Pseudo expression providing additional coefficient-wise operations.
Definition: Cwise.h:50
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:50
Dense storage base class for matrices and arrays.
Expression of the multiple replication of a matrix or vector.
Definition: Replicate.h:62
Standard SVD decomposition of a matrix and associated features.
Definition: SVD.h:30
Common base class for compact rotation representations.
Expression of a minor.
Definition: Minor.h:53
Expression of a selfadjoint matrix from a triangular part of a dense matrix.
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:35
Definition: QR.h:17
ComplexScalar type(ComplexScalar, int)
Represents a rotation/orientation in a 2 dimensional space.
Expression of a fixed-size or dynamic-size block.
Definition: Core/Block.h:102
The quaternion class used to represent 3D orientations and rotations.
LU decomposition of a matrix with complete pivoting, and related features.
Householder QR decomposition of a matrix.
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:42
Two-sided Jacobi SVD decomposition of a rectangular matrix.
Base class for triangular part in a matrix.
Expression of a diagonal matrix.
Proxy for the matrix exponential of some matrix (expression).
Helper class to get the correct and optimized returned type of operator*.
Expression of a diagonal/subdiagonal/superdiagonal in a matrix.
Definition: Diagonal.h:64
Generic expression where a coefficient-wise unary operator is applied to an expression.
Definition: CwiseUnaryOp.h:59
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:127
Pseudo expression providing matrix output with given format.
Definition: IO.h:90
Expression of the reverse of a vector or matrix.
Definition: Reverse.h:70
Proxy for the matrix power of some matrix (expression).
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48
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).
Expression of one (or a set of) homogeneous vector(s)
Definition: Homogeneous.h:61
Expression of a coefficient wise version of the C++ ternary operator ?:
Definition: Select.h:55


acado
Author(s): Milan Vukov, Rien Quirynen
autogenerated on Mon Jun 10 2019 12:34:34