1 | // This file is part of Eigen, a lightweight C++ template library |
2 | // for linear algebra. |
3 | // |
4 | // Copyright (C) 2007-2010 Benoit Jacob <[email protected]> |
5 | // Copyright (C) 2008-2009 Gael Guennebaud <[email protected]> |
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 | 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 | template<typename Derived, int Level> class DenseCoeffsBase; |
51 | |
52 | template<typename _Scalar, int _Rows, int _Cols, |
53 | int _Options = AutoAlign | |
54 | #if EIGEN_GNUC_AT(3,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) ? Eigen::RowMajor |
61 | : !(_Cols==1 && _Rows!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION |
62 | : Eigen::ColMajor ), |
63 | #else |
64 | ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor |
65 | : (_Cols==1 && _Rows!=1) ? Eigen::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> 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 TernaryOp, typename Arg1, typename Arg2, typename Arg3> class CwiseTernaryOp; |
91 | template<typename Decomposition, typename Rhstype> class Solve; |
92 | template<typename XprType> class Inverse; |
93 | |
94 | template<typename Lhs, typename Rhs, int Option = DefaultProduct> class Product; |
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<int Value = Dynamic> class InnerStride; |
113 | template<int Value = Dynamic> class OuterStride; |
114 | template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map; |
115 | template<typename Derived> class RefBase; |
116 | template<typename PlainObjectType, int Options = 0, |
117 | typename StrideType = typename internal::conditional<PlainObjectType::IsVectorAtCompileTime,InnerStride<1>,OuterStride<> >::type > class Ref; |
118 | |
119 | template<typename Derived> class TriangularBase; |
120 | template<typename MatrixType, unsigned int Mode> class TriangularView; |
121 | template<typename MatrixType, unsigned int Mode> class SelfAdjointView; |
122 | template<typename MatrixType> class SparseView; |
123 | template<typename ExpressionType> class WithFormat; |
124 | template<typename MatrixType> struct CommaInitializer; |
125 | template<typename Derived> class ReturnByValue; |
126 | template<typename ExpressionType> class ArrayWrapper; |
127 | template<typename ExpressionType> class MatrixWrapper; |
128 | template<typename Derived> class SolverBase; |
129 | template<typename XprType> class InnerIterator; |
130 | |
131 | namespace internal { |
132 | template<typename DecompositionType> struct kernel_retval_base; |
133 | template<typename DecompositionType> struct kernel_retval; |
134 | template<typename DecompositionType> struct image_retval_base; |
135 | template<typename DecompositionType> struct image_retval; |
136 | } // end namespace internal |
137 | |
138 | namespace internal { |
139 | template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix; |
140 | } |
141 | |
142 | namespace internal { |
143 | template<typename Lhs, typename Rhs> struct product_type; |
144 | |
145 | template<bool> struct EnableIf; |
146 | |
147 | /** \internal |
148 | * \class product_evaluator |
149 | * Products need their own evaluator with more template arguments allowing for |
150 | * easier partial template specializations. |
151 | */ |
152 | template< typename T, |
153 | int ProductTag = internal::product_type<typename T::Lhs,typename T::Rhs>::ret, |
154 | typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape, |
155 | typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape, |
156 | typename LhsScalar = typename traits<typename T::Lhs>::Scalar, |
157 | typename RhsScalar = typename traits<typename T::Rhs>::Scalar |
158 | > struct product_evaluator; |
159 | } |
160 | |
161 | template<typename Lhs, typename Rhs, |
162 | int ProductType = internal::product_type<Lhs,Rhs>::value> |
163 | struct ProductReturnType; |
164 | |
165 | // this is a workaround for sun CC |
166 | template<typename Lhs, typename Rhs> struct LazyProductReturnType; |
167 | |
168 | namespace internal { |
169 | |
170 | // Provides scalar/packet-wise product and product with accumulation |
171 | // with optional conjugation of the arguments. |
172 | template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper; |
173 | |
174 | template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_sum_op; |
175 | template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_difference_op; |
176 | template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_conj_product_op; |
177 | template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_min_op; |
178 | template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_max_op; |
179 | template<typename Scalar> struct scalar_opposite_op; |
180 | template<typename Scalar> struct scalar_conjugate_op; |
181 | template<typename Scalar> struct scalar_real_op; |
182 | template<typename Scalar> struct scalar_imag_op; |
183 | template<typename Scalar> struct scalar_abs_op; |
184 | template<typename Scalar> struct scalar_abs2_op; |
185 | template<typename Scalar> struct scalar_sqrt_op; |
186 | template<typename Scalar> struct scalar_rsqrt_op; |
187 | template<typename Scalar> struct scalar_exp_op; |
188 | template<typename Scalar> struct scalar_log_op; |
189 | template<typename Scalar> struct scalar_cos_op; |
190 | template<typename Scalar> struct scalar_sin_op; |
191 | template<typename Scalar> struct scalar_acos_op; |
192 | template<typename Scalar> struct scalar_asin_op; |
193 | template<typename Scalar> struct scalar_tan_op; |
194 | template<typename Scalar> struct scalar_inverse_op; |
195 | template<typename Scalar> struct scalar_square_op; |
196 | template<typename Scalar> struct scalar_cube_op; |
197 | template<typename Scalar, typename NewType> struct scalar_cast_op; |
198 | template<typename Scalar> struct scalar_random_op; |
199 | template<typename Scalar> struct scalar_constant_op; |
200 | template<typename Scalar> struct scalar_identity_op; |
201 | template<typename Scalar,bool iscpx> struct scalar_sign_op; |
202 | template<typename Scalar,typename ScalarExponent> struct scalar_pow_op; |
203 | template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_hypot_op; |
204 | template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op; |
205 | template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op; |
206 | |
207 | // SpecialFunctions module |
208 | template<typename Scalar> struct scalar_lgamma_op; |
209 | template<typename Scalar> struct scalar_digamma_op; |
210 | template<typename Scalar> struct scalar_erf_op; |
211 | template<typename Scalar> struct scalar_erfc_op; |
212 | template<typename Scalar> struct scalar_igamma_op; |
213 | template<typename Scalar> struct scalar_igammac_op; |
214 | template<typename Scalar> struct scalar_zeta_op; |
215 | template<typename Scalar> struct scalar_betainc_op; |
216 | |
217 | } // end namespace internal |
218 | |
219 | struct IOFormat; |
220 | |
221 | // Array module |
222 | template<typename _Scalar, int _Rows, int _Cols, |
223 | int _Options = AutoAlign | |
224 | #if EIGEN_GNUC_AT(3,4) |
225 | // workaround a bug in at least gcc 3.4.6 |
226 | // the innermost ?: ternary operator is misparsed. We write it slightly |
227 | // differently and this makes gcc 3.4.6 happy, but it's ugly. |
228 | // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined |
229 | // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor) |
230 | ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor |
231 | : !(_Cols==1 && _Rows!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION |
232 | : Eigen::ColMajor ), |
233 | #else |
234 | ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor |
235 | : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor |
236 | : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ), |
237 | #endif |
238 | int _MaxRows = _Rows, int _MaxCols = _Cols> class Array; |
239 | template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select; |
240 | template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr; |
241 | template<typename ExpressionType, int Direction> class VectorwiseOp; |
242 | template<typename MatrixType,int RowFactor,int ColFactor> class Replicate; |
243 | template<typename MatrixType, int Direction = BothDirections> class Reverse; |
244 | |
245 | template<typename MatrixType> class FullPivLU; |
246 | template<typename MatrixType> class PartialPivLU; |
247 | namespace internal { |
248 | template<typename MatrixType> struct inverse_impl; |
249 | } |
250 | template<typename MatrixType> class HouseholderQR; |
251 | template<typename MatrixType> class ColPivHouseholderQR; |
252 | template<typename MatrixType> class FullPivHouseholderQR; |
253 | template<typename MatrixType> class CompleteOrthogonalDecomposition; |
254 | template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD; |
255 | template<typename MatrixType> class BDCSVD; |
256 | template<typename MatrixType, int UpLo = Lower> class LLT; |
257 | template<typename MatrixType, int UpLo = Lower> class LDLT; |
258 | template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence; |
259 | template<typename Scalar> class JacobiRotation; |
260 | |
261 | // Geometry module: |
262 | template<typename Derived, int _Dim> class RotationBase; |
263 | template<typename Lhs, typename Rhs> class Cross; |
264 | template<typename Derived> class QuaternionBase; |
265 | template<typename Scalar> class Rotation2D; |
266 | template<typename Scalar> class AngleAxis; |
267 | template<typename Scalar,int Dim> class Translation; |
268 | template<typename Scalar,int Dim> class AlignedBox; |
269 | template<typename Scalar, int Options = AutoAlign> class Quaternion; |
270 | template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform; |
271 | template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine; |
272 | template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane; |
273 | template<typename Scalar> class UniformScaling; |
274 | template<typename MatrixType,int Direction> class Homogeneous; |
275 | |
276 | // Sparse module: |
277 | template<typename Derived> class SparseMatrixBase; |
278 | |
279 | // MatrixFunctions module |
280 | template<typename Derived> struct MatrixExponentialReturnValue; |
281 | template<typename Derived> class MatrixFunctionReturnValue; |
282 | template<typename Derived> class MatrixSquareRootReturnValue; |
283 | template<typename Derived> class MatrixLogarithmReturnValue; |
284 | template<typename Derived> class MatrixPowerReturnValue; |
285 | template<typename Derived> class MatrixComplexPowerReturnValue; |
286 | |
287 | namespace internal { |
288 | template <typename Scalar> |
289 | struct stem_function |
290 | { |
291 | typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar; |
292 | typedef ComplexScalar type(ComplexScalar, int); |
293 | }; |
294 | } |
295 | |
296 | } // end namespace Eigen |
297 | |
298 | #endif // EIGEN_FORWARDDECLARATIONS_H |
299 | |