| /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/clang/include/clang/Sema/ |
| CleanupInfo.h | 39 void mergeFrom(CleanupInfo Rhs) {
40 ExprNeedsCleanups |= Rhs.ExprNeedsCleanups;
41 CleanupsHaveSideEffects |= Rhs.CleanupsHaveSideEffects;
|
| /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...] |
| ProductEvaluators.h | 28 template<typename Lhs, typename Rhs, int Options>
29 struct evaluator<Product<Lhs, Rhs, Options> >
30 : public product_evaluator<Product<Lhs, Rhs, Options> >
32 typedef Product<Lhs, Rhs, Options> XprType;
40 template<typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
43 const Product<Lhs, Rhs, DefaultProduct> > >
47 template<typename Lhs, typename Rhs, typename Scalar1, typename Scalar2, typename Plain1>
50 const Product<Lhs, Rhs, DefaultProduct> > >
51 : public evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1,Lhs,product), Rhs, DefaultProduct> >
55 const Product<Lhs, Rhs, DefaultProduct> > XprType
[all...] |
| Product.h | 15 template<typename Lhs, typename Rhs, int Option, typename StorageKind> class ProductImpl;
19 template<typename Lhs, typename Rhs, int Option>
20 struct traits<Product<Lhs, Rhs, Option> >
23 typedef typename remove_all<Rhs>::type RhsCleaned;
32 internal::product_type<Lhs,Rhs>::ret>::ret StorageKind;
79 typedef _Rhs Rhs;
82 Lhs, Rhs, Option,
84 typename internal::traits<Rhs>::StorageKind,
85 internal::product_type<Lhs,Rhs>::ret>::ret>::Base Base;
89 typedef typename internal::ref_selector<Rhs>::type RhsNested
104 EIGEN_DEVICE_FUNC const RhsNestedCleaned& rhs() const { return m_rhs; } function in class:Eigen::Product
[all...] |
| CwiseBinaryOp.h | 17 template<typename BinaryOp, typename Lhs, typename Rhs>
18 struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
31 // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
36 const typename Rhs::Scalar&
40 typename traits<Rhs>::StorageKind,
43 typename traits<Rhs>::StorageIndex>::type StorageIndex;
45 typedef typename Rhs::Nested RhsNested;
49 Flags = cwise_promote_storage_order<typename traits<Lhs>::StorageKind,typename traits<Rhs>::StorageKind,_LhsNested::Flags & RowMajorBit,_RhsNested::Flags & RowMajorBit>::value
54 template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
89 typedef typename internal::remove_all<RhsType>::type Rhs;
135 const _RhsNested& rhs() const { return m_rhs; } function in class:Eigen::CwiseBinaryOp
[all...] |
| /external/dtc/ |
| srcpos.h | 81 #define YYLLOC_DEFAULT(Current, Rhs, N) \
84 (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \
85 (Current).first_column = YYRHSLOC(Rhs, 1).first_column; \
86 (Current).last_line = YYRHSLOC(Rhs, N).last_line; \
87 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
88 (Current).file = YYRHSLOC(Rhs, N).file; \
91 YYRHSLOC(Rhs, 0).last_line; \
93 YYRHSLOC(Rhs, 0).last_column; \
94 (Current).file = YYRHSLOC (Rhs, 0).file; \
|
| /external/u-boot/scripts/dtc/ |
| srcpos.h | 81 #define YYLLOC_DEFAULT(Current, Rhs, N) \
84 (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \
85 (Current).first_column = YYRHSLOC(Rhs, 1).first_column; \
86 (Current).last_line = YYRHSLOC(Rhs, N).last_line; \
87 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
88 (Current).file = YYRHSLOC(Rhs, N).file; \
91 YYRHSLOC(Rhs, 0).last_line; \
93 YYRHSLOC(Rhs, 0).last_column; \
94 (Current).file = YYRHSLOC (Rhs, 0).file; \
|
| /external/eigen/Eigen/src/SparseCore/ |
| SparseProduct.h | 37 template<typename Lhs, typename Rhs, int ProductType>
38 struct generic_product_impl<Lhs, Rhs, SparseShape, SparseShape, ProductType>
41 static void evalTo(Dest& dst, const Lhs& lhs, const Rhs& rhs)
43 evalTo(dst, lhs, rhs, typename evaluator_traits<Dest>::Shape());
48 static void addTo(Dest& dst, const ActualLhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>::type* = 0)
51 typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
53 RhsNested rhsNested(rhs);
60 static void subTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, typename enable_if<is_same<typename evaluator_traits<Dest>::Shape,DenseShape>::value,int*>:: (…)
[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());
43 evaluator<Rhs> rhsEval(rhs);
46 // given a rhs column containing Y non zeros, we assume that the respective Y columns
48 // the product of a rhs column with the lhs is X+Y where X is the average number of non zer
[all...] |
| SparseSolverBase.h | 19 * The rhs is decomposed into small vertical panels which are solved through dense temporaries.
21 template<typename Decomposition, typename Rhs, typename Dest>
22 typename enable_if<Rhs::ColsAtCompileTime!=1 && Dest::ColsAtCompileTime!=1>::type
23 solve_sparse_through_dense_panels(const Decomposition &dec, const Rhs& rhs, Dest &dest)
27 // we process the sparse rhs per block of NbColsAtOnce columns temporarily stored into a dense matrix.
29 Index rhsCols = rhs.cols();
30 Index size = rhs.rows();
38 tmp.leftCols(actualCols) = rhs.middleCols(k,actualCols);
44 // Overload for vector as rhs
[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, bool sortedInsertion = false)
24 Index cols = rhs.outerSize();
25 eigen_assert(lhs.outerSize() == rhs.innerSize());
34 evaluator<Rhs> rhsEval(rhs);
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...] |
| SparseDiagonalProduct.h | 37 template<typename Lhs, typename Rhs, int ProductTag>
38 struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, DiagonalShape, SparseShape>
39 : public sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct>
41 typedef Product<Lhs, Rhs, DefaultProduct> XprType;
42 enum { CoeffReadCost = HugeCost, Flags = Rhs::Flags&RowMajorBit, Alignment = 0 }; // FIXME CoeffReadCost & Flags
44 typedef sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct> Base;
45 explicit product_evaluator(const XprType& xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) {}
48 template<typename Lhs, typename Rhs, int ProductTag
[all...] |
| SparseDenseProduct.h | 30 typedef typename internal::remove_all<DenseRhsType>::type Rhs;
34 static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha)
44 for(Index c=0; c<rhs.cols(); ++c)
53 processRow(lhsEval,rhs,res,alpha,i,c);
59 processRow(lhsEval,rhs,res,alpha,i,c);
64 static void processRow(const LhsEval& lhsEval, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha, Index i, Index col)
68 tmp += it.value() * rhs.coeff(it.index(),col);
89 typedef typename internal::remove_all<DenseRhsType>::type Rhs;
92 static void run(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
95 for(Index c=0; c<rhs.cols(); ++c
[all...] |
| SparseCwiseBinaryOp.h | 35 template<typename BinaryOp, typename Lhs, typename Rhs>
36 class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse>
37 : public SparseMatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
40 typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
47 typename internal::traits<Rhs>::StorageKind>::value)
48 || ((internal::evaluator<Lhs>::Flags&RowMajorBit) == (internal::evaluator<Rhs>::Flags&RowMajorBit))),
59 template<typename BinaryOp, typename Lhs, typename Rhs>
60 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IteratorBased>
61 : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
65 typedef typename evaluator<Rhs>::InnerIterator RhsIterator
[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;
33 static void run(const Lhs& lhs, Rhs& other)
64 template<typename Lhs, typename Rhs, int Mode>
65 struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,RowMajor>
67 typedef typename Rhs::Scalar Scalar;
70 static void run(const Lhs& lhs, Rhs& other)
103 template<typename Lhs, typename Rhs, int Mode
[all...] |
| /external/eigen/unsupported/Eigen/src/KroneckerProduct/ |
| KroneckerTensorProduct.h | 33 typedef typename Traits::Rhs Rhs;
37 KroneckerProductBase(const Lhs& A, const Rhs& B)
66 typename Rhs::Nested m_B;
79 * \tparam Rhs Type of the rignt-hand side, a matrix expression.
81 template<typename Lhs, typename Rhs>
82 class KroneckerProduct : public KroneckerProductBase<KroneckerProduct<Lhs,Rhs> >
91 KroneckerProduct(const Lhs& A, const Rhs& B)
112 * \tparam Rhs Type of the rignt-hand side, a matrix expression.
114 template<typename Lhs, typename Rhs>
[all...] |
| /external/googletest/googletest/include/gtest/ |
| gtest-matchers.h | 590 // The following template definition assumes that the Rhs parameter is
592 template <typename D, typename Rhs, typename Op>
595 explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
607 template <typename Lhs, typename = Rhs>
610 explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
625 Rhs rhs_
[all...] |
| /external/swiftshader/third_party/llvm-7.0/llvm/include/llvm/ADT/ |
| ScopeExit.h | 34 scope_exit(scope_exit &&Rhs)
35 : ExitFunction(std::move(Rhs.ExitFunction)), Engaged(Rhs.Engaged) {
36 Rhs.release();
|
| /external/eigen/doc/examples/ |
| matrixfree_cg.cpp | 36 template<typename Rhs>
37 Eigen::Product<MatrixReplacement,Rhs,Eigen::AliasFreeProduct> operator*(const Eigen::MatrixBase<Rhs>& x) const {
38 return Eigen::Product<MatrixReplacement,Rhs,Eigen::AliasFreeProduct>(*this, x.derived());
58 template<typename Rhs>
59 struct generic_product_impl<MatrixReplacement, Rhs, SparseShape, DenseShape, GemvProduct> // GEMV stands for matrix-vector
60 : generic_product_impl_base<MatrixReplacement,Rhs,generic_product_impl<MatrixReplacement,Rhs> >
62 typedef typename Product<MatrixReplacement,Rhs>::Scalar Scalar;
65 static void scaleAndAddTo(Dest& dst, const MatrixReplacement& lhs, const Rhs& rhs, const Scalar& alpha
[all...] |
| /external/gemmlowp/internal/ |
| kernel_reference.h | 39 "reference(Lhs: %d cells %dx%d %s, Rhs: %d cells %dx%d %s)",
42 CellOrderName(Format::Lhs::Cell::kOrder), Format::Rhs::kCells,
43 Format::Rhs::Cell::kDepth, Format::Rhs::Cell::kWidth,
44 CellOrderName(Format::Rhs::Cell::kOrder));
60 // and over cells of the Rhs (stacked horizontally).
65 for (int cc = 0; cc < Format::Rhs::kCells; cc++) {
67 rhs_ptr + (dc * Format::Rhs::kCells + cc) *
68 Format::Rhs::Cell::kWidth * Format::kDepth;
71 // of the Rhs, so the remaining inner loops are jus
[all...] |
| simd_wrappers.h | 40 inline void MulAdd(std::int32_t lhs, std::int32_t rhs, std::int32_t* acc) {
41 *acc += lhs * rhs;
78 const RegisterBlockType& rhs) {
81 result.buf.reg[i] = Add(lhs.buf.reg[i], rhs.buf.reg[i]);
89 const RegisterBlockType& rhs) {
90 return RegisterBlockAddImpl<RegisterBlockType>::Run(lhs, rhs);
107 const RhsType& rhs) {
111 const RhsType& rhs) {
112 return rhs;
121 const RhsType& rhs) {
[all...] |
| /external/eigen/unsupported/Eigen/src/Skyline/ |
| SkylineProduct.h | 15 template<typename Lhs, typename Rhs, int ProductMode>
17 typedef const typename internal::nested_eval<Lhs, Rhs::RowsAtCompileTime>::type LhsNested;
18 typedef const typename internal::nested_eval<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 | 56 template<typename MatrixType,typename Rhs> struct homogeneous_right_product_impl;
80 template<typename Rhs>
81 EIGEN_DEVICE_FUNC inline const Product<Homogeneous,Rhs>
82 operator* (const MatrixBase<Rhs>& rhs) const
85 return Product<Homogeneous,Rhs>(*this,rhs.derived());
90 operator* (const MatrixBase<Lhs>& lhs, const Homogeneous& rhs)
93 return Product<Lhs,Homogeneous>(lhs.derived(),rhs);
98 operator* (const Transform<Scalar,Dim,Mode,Options>& lhs, const Homogeneous& rhs)
[all...] |
| /external/eigen/Eigen/src/IterativeLinearSolvers/ |
| BasicPreconditioners.h | 88 template<typename Rhs, typename Dest>
89 void _solve_impl(const Rhs& b, Dest& x) const
94 template<typename Rhs> inline const Solve<DiagonalPreconditioner, Rhs>
95 solve(const MatrixBase<Rhs>& b) const
100 return Solve<DiagonalPreconditioner, Rhs>(*this, b.derived());
218 template<typename Rhs>
219 inline const Rhs& solve(const Rhs& b) const { return b; }
|
