xref: /aosp_15_r20/external/eigen/Eigen/src/Core/util/ForwardDeclarations.h (revision bf2c37156dfe67e5dfebd6d394bad8b2ab5804d4) 
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 template<typename XprType, typename RowIndices, typename ColIndices> class IndexedView;
83 template<typename XprType, int Rows=Dynamic, int Cols=Dynamic, int Order=0> class Reshaped;
84 
85 template<typename MatrixType, int Size=Dynamic> class VectorBlock;
86 template<typename MatrixType> class Transpose;
87 template<typename MatrixType> class Conjugate;
88 template<typename NullaryOp, typename MatrixType>         class CwiseNullaryOp;
89 template<typename UnaryOp,   typename MatrixType>         class CwiseUnaryOp;
90 template<typename ViewOp,    typename MatrixType>         class CwiseUnaryView;
91 template<typename BinaryOp,  typename Lhs, typename Rhs>  class CwiseBinaryOp;
92 template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>  class CwiseTernaryOp;
93 template<typename Decomposition, typename Rhstype>        class Solve;
94 template<typename XprType>                                class Inverse;
95 
96 template<typename Lhs, typename Rhs, int Option = DefaultProduct> class Product;
97 
98 template<typename Derived> class DiagonalBase;
99 template<typename _DiagonalVectorType> class DiagonalWrapper;
100 template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
101 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
102 template<typename MatrixType, int Index = 0> class Diagonal;
103 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
104 template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
105 template<typename Derived> class PermutationBase;
106 template<typename Derived> class TranspositionsBase;
107 template<typename _IndicesType> class PermutationWrapper;
108 template<typename _IndicesType> class TranspositionsWrapper;
109 
110 template<typename Derived,
111          int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
112 > class MapBase;
113 template<int OuterStrideAtCompileTime, int InnerStrideAtCompileTime> class Stride;
114 template<int Value = Dynamic> class InnerStride;
115 template<int Value = Dynamic> class OuterStride;
116 template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
117 template<typename Derived> class RefBase;
118 template<typename PlainObjectType, int Options = 0,
119          typename StrideType = typename internal::conditional<PlainObjectType::IsVectorAtCompileTime,InnerStride<1>,OuterStride<> >::type > class Ref;
120 
121 template<typename Derived> class TriangularBase;
122 template<typename MatrixType, unsigned int Mode> class TriangularView;
123 template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
124 template<typename MatrixType> class SparseView;
125 template<typename ExpressionType> class WithFormat;
126 template<typename MatrixType> struct CommaInitializer;
127 template<typename Derived> class ReturnByValue;
128 template<typename ExpressionType> class ArrayWrapper;
129 template<typename ExpressionType> class MatrixWrapper;
130 template<typename Derived> class SolverBase;
131 template<typename XprType> class InnerIterator;
132 
133 namespace internal {
134 template<typename XprType> class generic_randaccess_stl_iterator;
135 template<typename XprType> class pointer_based_stl_iterator;
136 template<typename XprType, DirectionType Direction> class subvector_stl_iterator;
137 template<typename XprType, DirectionType Direction> class subvector_stl_reverse_iterator;
138 template<typename DecompositionType> struct kernel_retval_base;
139 template<typename DecompositionType> struct kernel_retval;
140 template<typename DecompositionType> struct image_retval_base;
141 template<typename DecompositionType> struct image_retval;
142 } // end namespace internal
143 
144 namespace internal {
145 template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
146 }
147 
148 namespace internal {
149 template<typename Lhs, typename Rhs> struct product_type;
150 
151 template<bool> struct EnableIf;
152 
153 /** \internal
154   * \class product_evaluator
155   * Products need their own evaluator with more template arguments allowing for
156   * easier partial template specializations.
157   */
158 template< typename T,
159           int ProductTag = internal::product_type<typename T::Lhs,typename T::Rhs>::ret,
160           typename LhsShape = typename evaluator_traits<typename T::Lhs>::Shape,
161           typename RhsShape = typename evaluator_traits<typename T::Rhs>::Shape,
162           typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
163           typename RhsScalar = typename traits<typename T::Rhs>::Scalar
164         > struct product_evaluator;
165 }
166 
167 template<typename Lhs, typename Rhs,
168          int ProductType = internal::product_type<Lhs,Rhs>::value>
169 struct ProductReturnType;
170 
171 // this is a workaround for sun CC
172 template<typename Lhs, typename Rhs> struct LazyProductReturnType;
173 
174 namespace internal {
175 
176 // Provides scalar/packet-wise product and product with accumulation
177 // with optional conjugation of the arguments.
178 template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
179 
180 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_sum_op;
181 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_difference_op;
182 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_conj_product_op;
183 template<typename LhsScalar,typename RhsScalar=LhsScalar, int NaNPropagation=PropagateFast> struct scalar_min_op;
184 template<typename LhsScalar,typename RhsScalar=LhsScalar, int NaNPropagation=PropagateFast> struct scalar_max_op;
185 template<typename Scalar> struct scalar_opposite_op;
186 template<typename Scalar> struct scalar_conjugate_op;
187 template<typename Scalar> struct scalar_real_op;
188 template<typename Scalar> struct scalar_imag_op;
189 template<typename Scalar> struct scalar_abs_op;
190 template<typename Scalar> struct scalar_abs2_op;
191 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_absolute_difference_op;
192 template<typename Scalar> struct scalar_sqrt_op;
193 template<typename Scalar> struct scalar_rsqrt_op;
194 template<typename Scalar> struct scalar_exp_op;
195 template<typename Scalar> struct scalar_log_op;
196 template<typename Scalar> struct scalar_cos_op;
197 template<typename Scalar> struct scalar_sin_op;
198 template<typename Scalar> struct scalar_acos_op;
199 template<typename Scalar> struct scalar_asin_op;
200 template<typename Scalar> struct scalar_tan_op;
201 template<typename Scalar> struct scalar_inverse_op;
202 template<typename Scalar> struct scalar_square_op;
203 template<typename Scalar> struct scalar_cube_op;
204 template<typename Scalar, typename NewType> struct scalar_cast_op;
205 template<typename Scalar> struct scalar_random_op;
206 template<typename Scalar> struct scalar_constant_op;
207 template<typename Scalar> struct scalar_identity_op;
208 template<typename Scalar,bool is_complex, bool is_integer> struct scalar_sign_op;
209 template<typename Scalar,typename ScalarExponent> struct scalar_pow_op;
210 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_hypot_op;
211 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
212 template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op;
213 
214 // SpecialFunctions module
215 template<typename Scalar> struct scalar_lgamma_op;
216 template<typename Scalar> struct scalar_digamma_op;
217 template<typename Scalar> struct scalar_erf_op;
218 template<typename Scalar> struct scalar_erfc_op;
219 template<typename Scalar> struct scalar_ndtri_op;
220 template<typename Scalar> struct scalar_igamma_op;
221 template<typename Scalar> struct scalar_igammac_op;
222 template<typename Scalar> struct scalar_zeta_op;
223 template<typename Scalar> struct scalar_betainc_op;
224 
225 // Bessel functions in SpecialFunctions module
226 template<typename Scalar> struct scalar_bessel_i0_op;
227 template<typename Scalar> struct scalar_bessel_i0e_op;
228 template<typename Scalar> struct scalar_bessel_i1_op;
229 template<typename Scalar> struct scalar_bessel_i1e_op;
230 template<typename Scalar> struct scalar_bessel_j0_op;
231 template<typename Scalar> struct scalar_bessel_y0_op;
232 template<typename Scalar> struct scalar_bessel_j1_op;
233 template<typename Scalar> struct scalar_bessel_y1_op;
234 template<typename Scalar> struct scalar_bessel_k0_op;
235 template<typename Scalar> struct scalar_bessel_k0e_op;
236 template<typename Scalar> struct scalar_bessel_k1_op;
237 template<typename Scalar> struct scalar_bessel_k1e_op;
238 
239 
240 } // end namespace internal
241 
242 struct IOFormat;
243 
244 // Array module
245 template<typename _Scalar, int _Rows, int _Cols,
246          int _Options = AutoAlign |
247 #if EIGEN_GNUC_AT(3,4)
248     // workaround a bug in at least gcc 3.4.6
249     // the innermost ?: ternary operator is misparsed. We write it slightly
250     // differently and this makes gcc 3.4.6 happy, but it's ugly.
251     // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined
252     // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor)
253                           ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
254                           : !(_Cols==1 && _Rows!=1) ?  EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION
255                           : Eigen::ColMajor ),
256 #else
257                           ( (_Rows==1 && _Cols!=1) ? Eigen::RowMajor
258                           : (_Cols==1 && _Rows!=1) ? Eigen::ColMajor
259                           : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ),
260 #endif
261          int _MaxRows = _Rows, int _MaxCols = _Cols> class Array;
262 template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
263 template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
264 template<typename ExpressionType, int Direction> class VectorwiseOp;
265 template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
266 template<typename MatrixType, int Direction = BothDirections> class Reverse;
267 
268 template<typename MatrixType> class FullPivLU;
269 template<typename MatrixType> class PartialPivLU;
270 namespace internal {
271 template<typename MatrixType> struct inverse_impl;
272 }
273 template<typename MatrixType> class HouseholderQR;
274 template<typename MatrixType> class ColPivHouseholderQR;
275 template<typename MatrixType> class FullPivHouseholderQR;
276 template<typename MatrixType> class CompleteOrthogonalDecomposition;
277 template<typename MatrixType> class SVDBase;
278 template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
279 template<typename MatrixType> class BDCSVD;
280 template<typename MatrixType, int UpLo = Lower> class LLT;
281 template<typename MatrixType, int UpLo = Lower> class LDLT;
282 template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
283 template<typename Scalar>     class JacobiRotation;
284 
285 // Geometry module:
286 template<typename Derived, int _Dim> class RotationBase;
287 template<typename Lhs, typename Rhs> class Cross;
288 template<typename Derived> class QuaternionBase;
289 template<typename Scalar> class Rotation2D;
290 template<typename Scalar> class AngleAxis;
291 template<typename Scalar,int Dim> class Translation;
292 template<typename Scalar,int Dim> class AlignedBox;
293 template<typename Scalar, int Options = AutoAlign> class Quaternion;
294 template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
295 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
296 template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
297 template<typename Scalar> class UniformScaling;
298 template<typename MatrixType,int Direction> class Homogeneous;
299 
300 // Sparse module:
301 template<typename Derived> class SparseMatrixBase;
302 
303 // MatrixFunctions module
304 template<typename Derived> struct MatrixExponentialReturnValue;
305 template<typename Derived> class MatrixFunctionReturnValue;
306 template<typename Derived> class MatrixSquareRootReturnValue;
307 template<typename Derived> class MatrixLogarithmReturnValue;
308 template<typename Derived> class MatrixPowerReturnValue;
309 template<typename Derived> class MatrixComplexPowerReturnValue;
310 
311 namespace internal {
312 template <typename Scalar>
313 struct stem_function
314 {
315   typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
316   typedef ComplexScalar type(ComplexScalar, int);
317 };
318 }
319 
320 } // end namespace Eigen
321 
322 #endif // EIGEN_FORWARDDECLARATIONS_H
323