| /bootable/recovery/edify/ |
| yydefs.h | 25 #define YYLLOC_DEFAULT(Current, Rhs, N) \
28 (Current).start = YYRHSLOC(Rhs, 1).start; \
29 (Current).end = YYRHSLOC(Rhs, N).end; \
31 (Current).start = YYRHSLOC(Rhs, 0).start; \
32 (Current).end = YYRHSLOC(Rhs, 0).end; \
|
| /external/eigen/Eigen/src/misc/ |
| Solve.h | 20 template<typename DecompositionType, typename Rhs>
21 struct traits<solve_retval_base<DecompositionType, Rhs> >
24 typedef Matrix<typename Rhs::Scalar,
26 Rhs::ColsAtCompileTime,
27 Rhs::PlainObject::Options,
29 Rhs::MaxColsAtCompileTime> ReturnType;
32 template<typename _DecompositionType, typename Rhs> struct solve_retval_base
33 : public ReturnByValue<solve_retval_base<_DecompositionType, Rhs> >
35 typedef typename remove_all<typename Rhs::Nested>::type RhsNestedCleaned;
40 solve_retval_base(const DecompositionType& dec, const Rhs& rhs
47 inline const RhsNestedCleaned& rhs() const { return m_rhs; } function in struct:Eigen::internal::solve_retval_base
[all...] |
| SparseSolve.h | 17 template<typename _DecompositionType, typename Rhs> struct sparse_solve_retval_base;
18 template<typename _DecompositionType, typename Rhs> struct sparse_solve_retval;
20 template<typename DecompositionType, typename Rhs>
21 struct traits<sparse_solve_retval_base<DecompositionType, Rhs> >
24 typedef SparseMatrix<typename Rhs::Scalar, Rhs::Options, typename Rhs::Index> ReturnType;
27 template<typename _DecompositionType, typename Rhs> struct sparse_solve_retval_base
28 : public ReturnByValue<sparse_solve_retval_base<_DecompositionType, Rhs> >
30 typedef typename remove_all<typename Rhs::Nested>::type RhsNestedCleaned
42 inline const RhsNestedCleaned& rhs() const { return m_rhs; } function in struct:Eigen::internal::sparse_solve_retval_base
[all...] |
| /external/eigen/Eigen/src/Core/ |
| SolveTriangular.h | 26 template<typename Lhs, typename Rhs, int Side>
31 RhsIsVectorAtCompileTime = (Side==OnTheLeft ? Rhs::ColsAtCompileTime : Rhs::RowsAtCompileTime)==1
35 Unrolling = (RhsIsVectorAtCompileTime && Rhs::SizeAtCompileTime != Dynamic && Rhs::SizeAtCompileTime <= 8)
41 template<typename Lhs, typename Rhs,
44 int Unrolling = trsolve_traits<Lhs,Rhs,Side>::Unrolling,
45 int RhsVectors = trsolve_traits<Lhs,Rhs,Side>::RhsVectors
49 template<typename Lhs, typename Rhs, int Side, int Mode>
50 struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,1
[all...] |
| NoAlias.h | 68 template<typename ProductDerived, typename Lhs, typename Rhs>
69 EIGEN_STRONG_INLINE ExpressionType& operator+=(const ProductBase<ProductDerived, Lhs,Rhs>& other)
72 template<typename ProductDerived, typename Lhs, typename Rhs>
73 EIGEN_STRONG_INLINE ExpressionType& operator-=(const ProductBase<ProductDerived, Lhs,Rhs>& other)
76 template<typename Lhs, typename Rhs, int NestingFlags>
77 EIGEN_STRONG_INLINE ExpressionType& operator+=(const CoeffBasedProduct<Lhs,Rhs,NestingFlags>& other)
78 { return m_expression.derived() += CoeffBasedProduct<Lhs,Rhs,NestByRefBit>(other.lhs(), other.rhs()); }
80 template<typename Lhs, typename Rhs, int NestingFlags>
81 EIGEN_STRONG_INLINE ExpressionType& operator-=(const CoeffBasedProduct<Lhs,Rhs,NestingFlags>& other
[all...] |
| CwiseBinaryOp.h | 23 * \param Rhs the type of the right-hand side
37 template<typename BinaryOp, typename Lhs, typename Rhs>
38 struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
51 // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
56 typename Rhs::Scalar
60 typename traits<Rhs>::StorageKind>::ret StorageKind;
62 typename traits<Rhs>::Index>::type Index;
64 typedef typename Rhs::Nested RhsNested;
73 StorageOrdersAgree = (int(Lhs::Flags)&RowMajorBit)==(int(Rhs::Flags)&RowMajorBit),
89 // we require Lhs and Rhs to have the same scalar type. Currently there is no example of a binary functo
152 const _RhsNested& rhs() const { return m_rhs; } function in class:Eigen::CwiseBinaryOp
[all...] |
| ProductBase.h | 26 typedef typename remove_all<_Rhs>::type Rhs;
27 typedef typename scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
29 typename traits<Rhs>::StorageKind>::ret StorageKind;
31 typename traits<Rhs>::Index>::type Index;
34 ColsAtCompileTime = traits<Rhs>::ColsAtCompileTime,
36 MaxColsAtCompileTime = traits<Rhs>::MaxColsAtCompileTime,
47 typedef ProductBase<Derived, Lhs, Rhs > Base; \
62 template<typename Derived, typename Lhs, typename Rhs>
76 typedef typename Rhs::Nested RhsNested;
81 typedef typename internal::traits<Rhs>::Scalar RhsScalar
114 const _RhsNested& rhs() const { return m_rhs; } function in class:Eigen::ProductBase
[all...] |
| GeneralProduct.h | 35 template<typename Lhs, typename Rhs, int ProductType = internal::product_type<Lhs,Rhs>::value>
57 template<typename Lhs, typename Rhs> struct product_type
60 typedef typename remove_all<Rhs>::type _Rhs;
137 * \param Rhs the type of the right-hand side
141 * between two matrix expressions. In practice, using ProductReturnType<Lhs,Rhs>::Type
148 template<typename Lhs, typename Rhs, int ProductType>
152 // typedef typename internal::nested<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
153 // typedef typename internal::nested<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
155 typedef GeneralProduct<Lhs/*Nested*/, Rhs/*Nested*/, ProductType> Type
[all...] |
| /external/eigen/Eigen/src/IterativeLinearSolvers/ |
| BasicPreconditioners.h | 83 template<typename Rhs, typename Dest>
84 void _solve(const Rhs& b, Dest& x) const
89 template<typename Rhs> inline const internal::solve_retval<DiagonalPreconditioner, Rhs>
90 solve(const MatrixBase<Rhs>& b) const
95 return internal::solve_retval<DiagonalPreconditioner, Rhs>(*this, b.derived());
105 template<typename _MatrixType, typename Rhs>
106 struct solve_retval<DiagonalPreconditioner<_MatrixType>, Rhs>
107 : solve_retval_base<DiagonalPreconditioner<_MatrixType>, Rhs>
110 EIGEN_MAKE_SOLVE_HELPERS(Dec,Rhs)
[all...] |
| IterativeSolverBase.h | 166 template<typename Rhs> inline const internal::solve_retval<Derived, Rhs>
167 solve(const MatrixBase<Rhs>& b) const
172 return internal::solve_retval<Derived, Rhs>(derived(), b.derived());
179 template<typename Rhs>
180 inline const internal::sparse_solve_retval<IterativeSolverBase, Rhs>
181 solve(const SparseMatrixBase<Rhs>& b) const
186 return internal::sparse_solve_retval<IterativeSolverBase, Rhs>(*this, b.derived());
197 template<typename Rhs, typename DestScalar, int DestOptions, typename DestIndex>
198 void _solve_sparse(const Rhs& b, SparseMatrix<DestScalar,DestOptions,DestIndex> &dest) cons
[all...] |
| BiCGSTAB.h | 20 * \param rhs The right hand side vector b
28 template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
29 bool bicgstab(const MatrixType& mat, const Rhs& rhs, Dest& x,
43 VectorType r = rhs - mat * x;
47 RealScalar rhs_sqnorm = rhs.squaredNorm();
212 template<typename Rhs,typename Guess>
213 inline const internal::solve_retval_with_guess<BiCGSTAB, Rhs, Guess>
214 solveWithGuess(const MatrixBase<Rhs>& b, const Guess& x0) const
220 <BiCGSTAB, Rhs, Guess>(*this, b.derived(), x0)
[all...] |
| ConjugateGradient.h | 19 * \param rhs The right hand side vector b
26 template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
28 void conjugate_gradient(const MatrixType& mat, const Rhs& rhs, Dest& x,
43 VectorType residual = rhs - mat * x; //initial residual
45 RealScalar rhsNorm2 = rhs.squaredNorm();
201 template<typename Rhs,typename Guess>
202 inline const internal::solve_retval_with_guess<ConjugateGradient, Rhs, Guess>
203 solveWithGuess(const MatrixBase<Rhs>& b, const Guess& x0) const
209 <ConjugateGradient, Rhs, Guess>(*this, b.derived(), x0)
[all...] |
| /external/eigen/Eigen/src/SparseCore/ |
| SparseDenseProduct.h | 15 template<typename Lhs, typename Rhs, int InnerSize> struct SparseDenseProductReturnType
17 typedef SparseTimeDenseProduct<Lhs,Rhs> Type;
20 template<typename Lhs, typename Rhs> struct SparseDenseProductReturnType<Lhs,Rhs,1>
24 SparseDenseOuterProduct<Rhs,Lhs,true>,
25 SparseDenseOuterProduct<Lhs,Rhs,false> >::type Type;
28 template<typename Lhs, typename Rhs, int InnerSize> struct DenseSparseProductReturnType
30 typedef DenseTimeSparseProduct<Lhs,Rhs> Type;
33 template<typename Lhs, typename Rhs> struct DenseSparseProductReturnType<Lhs,Rhs,1
109 EIGEN_STRONG_INLINE const _RhsNested& rhs() const { return m_rhs; } function in class:Eigen::SparseDenseOuterProduct
[all...] |
| SparseDiagonalProduct.h | 29 template<typename Lhs, typename Rhs>
30 struct traits<SparseDiagonalProduct<Lhs, Rhs> >
33 typedef typename remove_all<Rhs>::type _Rhs;
36 typename traits<Rhs>::Index>::type Index;
53 template<typename Lhs, typename Rhs, typename SparseDiagonalProductType, int RhsMode, int LhsMode>
58 template<typename Lhs, typename Rhs>
60 : public SparseMatrixBase<SparseDiagonalProduct<Lhs,Rhs> >,
64 typedef typename Rhs::Nested RhsNested;
87 EIGEN_STRONG_INLINE SparseDiagonalProduct(const Lhs& lhs, const Rhs& rhs)
97 EIGEN_STRONG_INLINE const _RhsNested& rhs() const { return m_rhs; } function in class:Eigen::SparseDiagonalProduct
[all...] |
| ConservativeSparseSparseProduct.h | 17 template<typename Lhs, typename Rhs, typename ResultType>
18 static void conservative_sparse_sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res)
25 Index cols = rhs.outerSize();
26 eigen_assert(lhs.outerSize() == rhs.innerSize());
33 // given a rhs column containing Y non zeros, we assume that the respective Y columns
35 // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
37 // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
38 Index estimated_nnz_prod = lhs.nonZeros() + rhs.nonZeros()
[all...] |
| SparseSparseProductWithPruning.h | 19 template<typename Lhs, typename Rhs, typename ResultType>
20 static void sparse_sparse_product_with_pruning_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res, const typename ResultType::RealScalar& tolerance)
22 // return sparse_sparse_product_with_pruning_impl2(lhs,rhs,res);
29 Index cols = rhs.outerSize();
31 eigen_assert(lhs.outerSize() == rhs.innerSize());
37 // given a rhs column containing Y non zeros, we assume that the respective Y columns
39 // the product of a rhs column with the lhs is X+Y where X is the average number of non zero
41 // Therefore, we have nnz(lhs*rhs) = nnz(lhs) + nnz(rhs)
[all...] |
| SparseCwiseBinaryOp.h | 40 template<typename BinaryOp, typename Lhs, typename Rhs, typename Derived,
42 typename _RhsStorageMode = typename traits<Rhs>::StorageKind>
47 template<typename BinaryOp, typename Lhs, typename Rhs>
48 class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse>
49 : public SparseMatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
54 typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
59 typedef typename internal::traits<Rhs>::StorageKind RhsStorageKind;
62 || ((Lhs::Flags&RowMajorBit) == (Rhs::Flags&RowMajorBit))),
67 template<typename BinaryOp, typename Lhs, typename Rhs>
68 class CwiseBinaryOpImpl<BinaryOp,Lhs,Rhs,Sparse>::InnerIterato
[all...] |
| TriangularSolver.h | 17 template<typename Lhs, typename Rhs, int Mode,
27 template<typename Lhs, typename Rhs, int Mode>
28 struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,RowMajor>
30 typedef typename Rhs::Scalar Scalar;
31 static void run(const Lhs& lhs, Rhs& other)
61 template<typename Lhs, typename Rhs, int Mode>
62 struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,RowMajor>
64 typedef typename Rhs::Scalar Scalar;
65 static void run(const Lhs& lhs, Rhs& other)
99 template<typename Lhs, typename Rhs, int Mode
[all...] |
| /external/eigen/Eigen/src/Core/products/ |
| CoeffBasedProduct.h | 31 template<int Traversal, int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar>
34 template<int StorageOrder, int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode>
147 template<typename Lhs, typename Rhs>
148 inline CoeffBasedProduct(const Lhs& lhs, const Rhs& rhs)
149 : m_lhs(lhs), m_rhs(rhs)
153 EIGEN_STATIC_ASSERT((internal::scalar_product_traits<typename Lhs::RealScalar, typename Rhs::RealScalar>::Defined),
155 eigen_assert(lhs.cols() == rhs.rows()
201 const _RhsNested& rhs() const { return m_rhs; } function in class:Eigen::CoeffBasedProduct
224 template<typename Lhs, typename Rhs, int N, typename PlainObject
[all...] |
| /external/eigen/Eigen/src/Eigen2Support/ |
| Lazy.h | 52 template<typename ProductDerived, typename Lhs, typename Rhs>
53 Derived& MatrixBase<Derived>::operator+=(const Flagged<ProductBase<ProductDerived, Lhs,Rhs>, 0,
62 template<typename ProductDerived, typename Lhs, typename Rhs>
63 Derived& MatrixBase<Derived>::operator-=(const Flagged<ProductBase<ProductDerived, Lhs,Rhs>, 0,
|
| /external/eigen/unsupported/Eigen/src/KroneckerProduct/ |
| KroneckerTensorProduct.h | 27 * \tparam Rhs Type of the rignt-hand side, a matrix expression.
29 template<typename Lhs, typename Rhs>
30 class KroneckerProduct : public ReturnByValue<KroneckerProduct<Lhs,Rhs> >
39 KroneckerProduct(const Lhs& A, const Rhs& B)
63 typename Rhs::Nested m_B;
77 * \tparam Rhs Type of the rignt-hand side, a matrix expression.
79 template<typename Lhs, typename Rhs>
80 class KroneckerProductSparse : public EigenBase<KroneckerProductSparse<Lhs,Rhs> >
87 KroneckerProductSparse(const Lhs& A, const Rhs& B)
107 typename Rhs::Nested m_B
[all...] |
| /external/eigen/unsupported/Eigen/src/IterativeSolvers/ |
| IncompleteLU.h | 73 template<typename Rhs, typename Dest>
74 void _solve(const Rhs& b, Dest& x) const
80 template<typename Rhs> inline const internal::solve_retval<IncompleteLU, Rhs>
81 solve(const MatrixBase<Rhs>& b) const
86 return internal::solve_retval<IncompleteLU, Rhs>(*this, b.derived());
96 template<typename _MatrixType, typename Rhs>
97 struct solve_retval<IncompleteLU<_MatrixType>, Rhs>
98 : solve_retval_base<IncompleteLU<_MatrixType>, Rhs>
101 EIGEN_MAKE_SOLVE_HELPERS(Dec,Rhs)
[all...] |
| MINRES.h | 22 * \param rhs The right hand side vector b
29 template<typename MatrixType, typename Rhs, typename Dest, typename Preconditioner>
31 void minres(const MatrixType& mat, const Rhs& rhs, Dest& x,
43 const RealScalar rhsNorm2(rhs.squaredNorm());
49 VectorType v_new(rhs-mat*x); //initialize v_new
238 template<typename Rhs,typename Guess>
239 inline const internal::solve_retval_with_guess<MINRES, Rhs, Guess>
240 solveWithGuess(const MatrixBase<Rhs>& b, const Guess& x0) const
246 <MINRES, Rhs, Guess>(*this, b.derived(), x0)
[all...] |
| /external/eigen/unsupported/Eigen/src/Skyline/ |
| SkylineProduct.h | 15 template<typename Lhs, typename Rhs, int ProductMode>
17 typedef const typename internal::nested<Lhs, Rhs::RowsAtCompileTime>::type LhsNested;
18 typedef const typename internal::nested<Rhs, Lhs::RowsAtCompileTime>::type RhsNested;
75 template<typename Lhs, typename Rhs>
76 EIGEN_STRONG_INLINE SkylineProduct(const Lhs& lhs, const Rhs& rhs)
77 : m_lhs(lhs), m_rhs(rhs) {
78 eigen_assert(lhs.cols() == rhs.rows());
109 EIGEN_STRONG_INLINE const _RhsNested& rhs() const { function in class:Eigen::internal::SkylineProduct
121 template<typename Lhs, typename Rhs, typename Dest
[all...] |
| /external/eigen/Eigen/src/Geometry/ |
| Homogeneous.h | 57 template<typename MatrixType,typename Rhs> struct homogeneous_right_product_impl;
86 template<typename Rhs>
87 inline const internal::homogeneous_right_product_impl<Homogeneous,Rhs>
88 operator* (const MatrixBase<Rhs>& rhs) const
91 return internal::homogeneous_right_product_impl<Homogeneous,Rhs>(m_matrix,rhs.derived());
96 operator* (const MatrixBase<Lhs>& lhs, const Homogeneous& rhs)
99 return internal::homogeneous_left_product_impl<Homogeneous,Lhs>(lhs.derived(),rhs.m_matrix);
104 operator* (const Transform<Scalar,Dim,Mode,Options>& lhs, const Homogeneous& rhs)
[all...] |
