Eigen  3.2.10
 
Loading...
Searching...
No Matches
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
14namespace Eigen {
15namespace internal {
16
17template<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> >
23template<typename T> struct traits<const T> : traits<T> {};
24
25template<typename Derived> struct has_direct_access
26{
27 enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 };
28};
29
30template<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
41template<typename T> struct NumTraits;
42
43template<typename Derived> struct EigenBase;
44template<typename Derived> class DenseBase;
45template<typename Derived> class PlainObjectBase;
46
47
48template<typename Derived,
49 int Level = internal::accessors_level<Derived>::value >
50class DenseCoeffsBase;
51
52template<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
72template<typename Derived> class MatrixBase;
73template<typename Derived> class ArrayBase;
74
75template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
76template<typename ExpressionType, template <typename> class StorageBase > class NoAlias;
77template<typename ExpressionType> class NestByValue;
78template<typename ExpressionType> class ForceAlignedAccess;
79template<typename ExpressionType> class SwapWrapper;
80
81template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false> class Block;
82
83template<typename MatrixType, int Size=Dynamic> class VectorBlock;
84template<typename MatrixType> class Transpose;
85template<typename MatrixType> class Conjugate;
86template<typename NullaryOp, typename MatrixType> class CwiseNullaryOp;
87template<typename UnaryOp, typename MatrixType> class CwiseUnaryOp;
88template<typename ViewOp, typename MatrixType> class CwiseUnaryView;
89template<typename BinaryOp, typename Lhs, typename Rhs> class CwiseBinaryOp;
90template<typename BinOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp;
91template<typename Derived, typename Lhs, typename Rhs> class ProductBase;
92template<typename Lhs, typename Rhs, int Mode> class GeneralProduct;
93template<typename Lhs, typename Rhs, int NestingFlags> class CoeffBasedProduct;
94
95template<typename Derived> class DiagonalBase;
96template<typename _DiagonalVectorType> class DiagonalWrapper;
97template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
98template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
99template<typename MatrixType, int Index = 0> class Diagonal;
100template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class PermutationMatrix;
101template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime, typename IndexType=int> class Transpositions;
102template<typename Derived> class PermutationBase;
103template<typename Derived> class TranspositionsBase;
104template<typename _IndicesType> class PermutationWrapper;
105template<typename _IndicesType> class TranspositionsWrapper;
106
107template<typename Derived,
108 int Level = internal::accessors_level<Derived>::has_write_access ? WriteAccessors : ReadOnlyAccessors
109> class MapBase;
110template<int InnerStrideAtCompileTime, int OuterStrideAtCompileTime> class Stride;
111template<typename MatrixType, int MapOptions=Unaligned, typename StrideType = Stride<0,0> > class Map;
112
113template<typename Derived> class TriangularBase;
114template<typename MatrixType, unsigned int Mode> class TriangularView;
115template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
116template<typename MatrixType> class SparseView;
117template<typename ExpressionType> class WithFormat;
118template<typename MatrixType> struct CommaInitializer;
119template<typename Derived> class ReturnByValue;
120template<typename ExpressionType> class ArrayWrapper;
121template<typename ExpressionType> class MatrixWrapper;
122
123namespace internal {
124template<typename DecompositionType, typename Rhs> struct solve_retval_base;
125template<typename DecompositionType, typename Rhs> struct solve_retval;
126template<typename DecompositionType> struct kernel_retval_base;
127template<typename DecompositionType> struct kernel_retval;
128template<typename DecompositionType> struct image_retval_base;
129template<typename DecompositionType> struct image_retval;
130} // end namespace internal
131
132namespace internal {
133template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix;
134}
135
136namespace internal {
137template<typename Lhs, typename Rhs> struct product_type;
138}
139
140template<typename Lhs, typename Rhs,
141 int ProductType = internal::product_type<Lhs,Rhs>::value>
142struct ProductReturnType;
143
144// this is a workaround for sun CC
145template<typename Lhs, typename Rhs> struct LazyProductReturnType;
146
147namespace internal {
148
149// Provides scalar/packet-wise product and product with accumulation
150// with optional conjugation of the arguments.
151template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper;
152
153template<typename Scalar> struct scalar_sum_op;
154template<typename Scalar> struct scalar_difference_op;
155template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op;
156template<typename Scalar> struct scalar_opposite_op;
157template<typename Scalar> struct scalar_conjugate_op;
158template<typename Scalar> struct scalar_real_op;
159template<typename Scalar> struct scalar_imag_op;
160template<typename Scalar> struct scalar_abs_op;
161template<typename Scalar> struct scalar_abs2_op;
162template<typename Scalar> struct scalar_sqrt_op;
163template<typename Scalar> struct scalar_exp_op;
164template<typename Scalar> struct scalar_log_op;
165template<typename Scalar> struct scalar_cos_op;
166template<typename Scalar> struct scalar_sin_op;
167template<typename Scalar> struct scalar_acos_op;
168template<typename Scalar> struct scalar_asin_op;
169template<typename Scalar> struct scalar_tan_op;
170template<typename Scalar> struct scalar_pow_op;
171template<typename Scalar> struct scalar_inverse_op;
172template<typename Scalar> struct scalar_square_op;
173template<typename Scalar> struct scalar_cube_op;
174template<typename Scalar, typename NewType> struct scalar_cast_op;
175template<typename Scalar> struct scalar_multiple_op;
176template<typename Scalar> struct scalar_quotient1_op;
177template<typename Scalar> struct scalar_min_op;
178template<typename Scalar> struct scalar_max_op;
179template<typename Scalar> struct scalar_random_op;
180template<typename Scalar> struct scalar_add_op;
181template<typename Scalar> struct scalar_constant_op;
182template<typename Scalar> struct scalar_identity_op;
183
184template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op;
185template<typename LhsScalar,typename RhsScalar> struct scalar_multiple2_op;
186template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_quotient_op;
187
188} // end namespace internal
189
190struct IOFormat;
191
192// Array module
193template<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;
210template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select;
211template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
212template<typename ExpressionType, int Direction> class VectorwiseOp;
213template<typename MatrixType,int RowFactor,int ColFactor> class Replicate;
214template<typename MatrixType, int Direction = BothDirections> class Reverse;
215
216template<typename MatrixType> class FullPivLU;
217template<typename MatrixType> class PartialPivLU;
218namespace internal {
219template<typename MatrixType> struct inverse_impl;
220}
221template<typename MatrixType> class HouseholderQR;
222template<typename MatrixType> class ColPivHouseholderQR;
223template<typename MatrixType> class FullPivHouseholderQR;
224template<typename MatrixType, int QRPreconditioner = ColPivHouseholderQRPreconditioner> class JacobiSVD;
225template<typename MatrixType, int UpLo = Lower> class LLT;
226template<typename MatrixType, int UpLo = Lower> class LDLT;
227template<typename VectorsType, typename CoeffsType, int Side=OnTheLeft> class HouseholderSequence;
228template<typename Scalar> class JacobiRotation;
229
230// Geometry module:
231template<typename Derived, int _Dim> class RotationBase;
232template<typename Lhs, typename Rhs> class Cross;
233template<typename Derived> class QuaternionBase;
234template<typename Scalar> class Rotation2D;
235template<typename Scalar> class AngleAxis;
236template<typename Scalar,int Dim> class Translation;
237
238// Sparse module:
239template<typename Derived> class SparseMatrixBase;
240
241#ifdef EIGEN2_SUPPORT
242template<typename Derived, int _Dim> class eigen2_RotationBase;
243template<typename Lhs, typename Rhs> class eigen2_Cross;
244template<typename Scalar> class eigen2_Quaternion;
245template<typename Scalar> class eigen2_Rotation2D;
246template<typename Scalar> class eigen2_AngleAxis;
247template<typename Scalar,int Dim> class eigen2_Transform;
248template <typename _Scalar, int _AmbientDim> class eigen2_ParametrizedLine;
249template <typename _Scalar, int _AmbientDim> class eigen2_Hyperplane;
250template<typename Scalar,int Dim> class eigen2_Translation;
251template<typename Scalar,int Dim> class eigen2_Scaling;
252#endif
253
254#if EIGEN2_SUPPORT_STAGE < STAGE20_RESOLVE_API_CONFLICTS
255template<typename Scalar> class Quaternion;
256template<typename Scalar,int Dim> class Transform;
257template <typename _Scalar, int _AmbientDim> class ParametrizedLine;
258template <typename _Scalar, int _AmbientDim> class Hyperplane;
259template<typename Scalar,int Dim> class Scaling;
260#endif
261
262#if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS
263template<typename Scalar, int Options = AutoAlign> class Quaternion;
264template<typename Scalar,int Dim,int Mode,int _Options=AutoAlign> class Transform;
265template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class ParametrizedLine;
266template <typename _Scalar, int _AmbientDim, int Options=AutoAlign> class Hyperplane;
267template<typename Scalar> class UniformScaling;
268template<typename MatrixType,int Direction> class Homogeneous;
269#endif
270
271// MatrixFunctions module
272template<typename Derived> struct MatrixExponentialReturnValue;
273template<typename Derived> class MatrixFunctionReturnValue;
274template<typename Derived> class MatrixSquareRootReturnValue;
275template<typename Derived> class MatrixLogarithmReturnValue;
276template<typename Derived> class MatrixPowerReturnValue;
277template<typename Derived, typename Lhs, typename Rhs> class MatrixPowerProduct;
278
279namespace internal {
280template <typename Scalar>
281struct stem_function
282{
283 typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
284 typedef ComplexScalar type(ComplexScalar, int);
285};
286}
287
288
289#ifdef EIGEN2_SUPPORT
290template<typename ExpressionType> class Cwise;
291template<typename MatrixType> class Minor;
292template<typename MatrixType> class LU;
293template<typename MatrixType> class QR;
294template<typename MatrixType> class SVD;
295namespace internal {
296template<typename MatrixType, unsigned int Mode> struct eigen2_part_return_type;
297}
298#endif
299
300} // end namespace Eigen
301
302#endif // EIGEN_FORWARDDECLARATIONS_H
Eigen::ArrayWrapper
Expression of a mathematical vector or matrix as an array object.
Definition ArrayWrapper.h:42
Eigen::MapBase
Base class for Map and Block expression with direct access.
Definition ForwardDeclarations.h:109
Eigen::Map
A matrix or vector expression mapping an existing array of data.
Definition Map.h:106
Eigen::MatrixWrapper
Expression of an array as a mathematical vector or matrix.
Definition ArrayWrapper.h:167
Eigen::SelfAdjointView
Expression of a selfadjoint matrix from a triangular part of a dense matrix.
Definition SelfAdjointView.h:55
Eigen::SparseView
Expression of a dense or sparse matrix with zero or too small values removed.
Definition SparseView.h:46
Eigen::Stride
Holds strides information for Map.
Definition Stride.h:45
Eigen::TriangularView
Base class for triangular part in a matrix.
Definition TriangularMatrix.h:160
Eigen::WithFormat
Pseudo expression providing matrix output with given format.
Definition IO.h:91
Eigen::WriteAccessors
@ WriteAccessors
Definition Constants.h:312
Eigen::ReadOnlyAccessors
@ ReadOnlyAccessors
Definition Constants.h:310
Eigen::DirectWriteAccessors
@ DirectWriteAccessors
Definition Constants.h:316
Eigen::DirectAccessors
@ DirectAccessors
Definition Constants.h:314
Eigen::AutoAlign
@ AutoAlign
Definition Constants.h:268
Eigen::RowMajor
@ RowMajor
Definition Constants.h:266
Eigen::ColMajor
@ ColMajor
Definition Constants.h:264
Eigen::DirectAccessBit
const unsigned int DirectAccessBit
Definition Constants.h:142
Eigen::LvalueBit
const unsigned int LvalueBit
Definition Constants.h:131
Eigen::internal
Definition LDLT.h:18
Eigen::CommaInitializer
Helper class used by the comma initializer operator.
Definition CommaInitializer.h:29