ForwardDeclarations.h
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 {
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 } // 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,
49  int Level = internal::accessors_level<Derived>::value >
50 class DenseCoeffsBase;
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
66  : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
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,
82  bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class Block;
83 
84 template<typename MatrixType, int Size=Dynamic> class VectorBlock;
85 template<typename MatrixType> class Transpose;
86 template<typename MatrixType> class Conjugate;
87 template<typename NullaryOp, typename MatrixType> class CwiseNullaryOp;
88 template<typename UnaryOp, typename MatrixType> class CwiseUnaryOp;
89 template<typename ViewOp, typename MatrixType> class CwiseUnaryView;
90 template<typename BinaryOp, typename Lhs, typename Rhs> class CwiseBinaryOp;
91 template<typename BinOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp;
92 template<typename Derived, typename Lhs, typename Rhs> class ProductBase;
93 template<typename Lhs, typename Rhs, int Mode> class GeneralProduct;
94 template<typename Lhs, typename Rhs, int NestingFlags> class CoeffBasedProduct;
95 
96 template<typename Derived> class DiagonalBase;
97 template<typename _DiagonalVectorType> class DiagonalWrapper;
98 template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
99 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
100 template<typename MatrixType, int Index = 0> class Diagonal;
101 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
102 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
103 template<typename Derived> class PermutationBase;
104 template<typename Derived> class TranspositionsBase;
105 template<typename _IndicesType> class PermutationWrapper;
106 template<typename _IndicesType> class TranspositionsWrapper;
107 
108 template<typename Derived,
109  int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
110 > class MapBase;
111 template<int InnerStrideAtCompileTime, int OuterStrideAtCompileTime> class Stride;
112 template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
113 
114 template<typename Derived> class TriangularBase;
115 template<typename MatrixType, unsigned int Mode> class TriangularView;
116 template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
117 template<typename MatrixType> class SparseView;
118 template<typename ExpressionType> class WithFormat;
119 template<typename MatrixType> struct CommaInitializer;
120 template<typename Derived> class ReturnByValue;
121 template<typename ExpressionType> class ArrayWrapper;
122 template<typename ExpressionType> class MatrixWrapper;
123 
124 namespace internal {
125 template<typename DecompositionType, typename Rhs> struct solve_retval_base;
126 template<typename DecompositionType, typename Rhs> struct solve_retval;
127 template<typename DecompositionType> struct kernel_retval_base;
128 template<typename DecompositionType> struct kernel_retval;
129 template<typename DecompositionType> struct image_retval_base;
130 template<typename DecompositionType> struct image_retval;
131 } // end namespace internal
132 
133 namespace internal {
134 template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
135 }
136 
137 namespace internal {
138 template<typename Lhs, typename Rhs> struct product_type;
139 }
140 
141 template<typename Lhs, typename Rhs,
142  int ProductType = internal::product_type<Lhs,Rhs>::value>
143 struct ProductReturnType;
144 
145 // this is a workaround for sun CC
146 template<typename Lhs, typename Rhs> struct LazyProductReturnType;
147 
148 namespace internal {
149 
150 // Provides scalar/packet-wise product and product with accumulation
151 // with optional conjugation of the arguments.
152 template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
153 
154 template<typename Scalar> struct scalar_sum_op;
155 template<typename Scalar> struct scalar_difference_op;
156 template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op;
157 template<typename Scalar> struct scalar_quotient_op;
158 template<typename Scalar> struct scalar_opposite_op;
159 template<typename Scalar> struct scalar_conjugate_op;
160 template<typename Scalar> struct scalar_real_op;
161 template<typename Scalar> struct scalar_imag_op;
162 template<typename Scalar> struct scalar_abs_op;
163 template<typename Scalar> struct scalar_abs2_op;
164 template<typename Scalar> struct scalar_sqrt_op;
165 template<typename Scalar> struct scalar_exp_op;
166 template<typename Scalar> struct scalar_log_op;
167 template<typename Scalar> struct scalar_cos_op;
168 template<typename Scalar> struct scalar_sin_op;
169 template<typename Scalar> struct scalar_acos_op;
170 template<typename Scalar> struct scalar_asin_op;
171 template<typename Scalar> struct scalar_tan_op;
172 template<typename Scalar> struct scalar_pow_op;
173 template<typename Scalar> struct scalar_inverse_op;
174 template<typename Scalar> struct scalar_square_op;
175 template<typename Scalar> struct scalar_cube_op;
176 template<typename Scalar, typename NewType> struct scalar_cast_op;
177 template<typename Scalar> struct scalar_multiple_op;
178 template<typename Scalar> struct scalar_quotient1_op;
179 template<typename Scalar> struct scalar_min_op;
180 template<typename Scalar> struct scalar_max_op;
181 template<typename Scalar> struct scalar_random_op;
182 template<typename Scalar> struct scalar_add_op;
183 template<typename Scalar> struct scalar_constant_op;
184 template<typename Scalar> struct scalar_identity_op;
185 
186 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
187 template<typename LhsScalar,typename RhsScalar> struct scalar_multiple2_op;
188 
189 } // end namespace internal
190 
191 struct IOFormat;
192 
193 // Array module
194 template<typename _Scalar, int _Rows, int _Cols,
195  int _Options = AutoAlign |
196 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==4
197  // workaround a bug in at least gcc 3.4.6
198  // the innermost ?: ternary operator is misparsed. We write it slightly
199  // differently and this makes gcc 3.4.6 happy, but it's ugly.
200  // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
201  // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
202  ( (_Rows==1 && _Cols!=1) ? RowMajor
203  : !(_Cols==1 && _Rows!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
204  : ColMajor ),
205 #else
206  ( (_Rows==1 && _Cols!=1) ? RowMajor
207  : (_Cols==1 && _Rows!=1) ? ColMajor
208  : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
209 #endif
210  int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
211 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
212 template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
213 template<typename ExpressionType, int Direction> class VectorwiseOp;
214 template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
215 template<typename MatrixType, int Direction = BothDirections> class Reverse;
216 
217 template<typename MatrixType> class FullPivLU;
218 template<typename MatrixType> class PartialPivLU;
219 namespace internal {
220 template<typename MatrixType> struct inverse_impl;
221 }
222 template<typename MatrixType> class HouseholderQR;
223 template<typename MatrixType> class ColPivHouseholderQR;
224 template<typename MatrixType> class FullPivHouseholderQR;
225 template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
226 template<typename MatrixType, int UpLo = Lower> class LLT;
227 template<typename MatrixType, int UpLo = Lower> class LDLT;
228 template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
229 template<typename Scalar> class JacobiRotation;
230 
231 // Geometry module:
232 template<typename Derived, int _Dim> class RotationBase;
233 template<typename Lhs, typename Rhs> class Cross;
234 template<typename Derived> class QuaternionBase;
235 template<typename Scalar> class Rotation2D;
236 template<typename Scalar> class AngleAxis;
237 template<typename Scalar,int Dim> class Translation;
238 
239 #ifdef EIGEN2_SUPPORT
240 template<typename Derived, int _Dim> class eigen2_RotationBase;
241 template<typename Lhs, typename Rhs> class eigen2_Cross;
242 template<typename Scalar> class eigen2_Quaternion;
243 template<typename Scalar> class eigen2_Rotation2D;
244 template<typename Scalar> class eigen2_AngleAxis;
245 template<typename Scalar,int Dim> class eigen2_Transform;
246 template <typename _Scalar, int _AmbientDim> class eigen2_ParametrizedLine;
247 template <typename _Scalar, int _AmbientDim> class eigen2_Hyperplane;
248 template<typename Scalar,int Dim> class eigen2_Translation;
249 template<typename Scalar,int Dim> class eigen2_Scaling;
250 #endif
251 
252 #if EIGEN2_SUPPORT_STAGE < STAGE20_RESOLVE_API_CONFLICTS
253 template<typename Scalar> class Quaternion;
254 template<typename Scalar,int Dim> class Transform;
255 template <typename _Scalar, int _AmbientDim> class ParametrizedLine;
256 template <typename _Scalar, int _AmbientDim> class Hyperplane;
257 template<typename Scalar,int Dim> class Scaling;
258 #endif
259 
260 #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS
261 template<typename Scalar, int Options = AutoAlign> class Quaternion;
262 template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
263 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
264 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
265 template<typename Scalar> class UniformScaling;
266 template<typename MatrixType,int Direction> class Homogeneous;
267 #endif
268 
269 // MatrixFunctions module
270 template<typename Derived> struct MatrixExponentialReturnValue;
271 template<typename Derived> class MatrixFunctionReturnValue;
272 template<typename Derived> class MatrixSquareRootReturnValue;
273 template<typename Derived> class MatrixLogarithmReturnValue;
274 
275 namespace internal {
276 template <typename Scalar>
277 struct stem_function
278 {
279  typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
280  typedef ComplexScalar type(ComplexScalar, int);
281 };
282 }
283 
284 
285 #ifdef EIGEN2_SUPPORT
286 template<typename ExpressionType> class Cwise;
287 template<typename MatrixType> class Minor;
288 template<typename MatrixType> class LU;
289 template<typename MatrixType> class QR;
290 template<typename MatrixType> class SVD;
291 namespace internal {
292 template<typename MatrixType, unsigned int Mode> struct eigen2_part_return_type;
293 }
294 #endif
295 
296 } // end namespace Eigen
297 
298 #endif // EIGEN_FORWARDDECLARATIONS_H