| /external/eigen/Eigen/src/Core/ |
| Ref.h | 105 InnerStrideMatch = int(StrideType::InnerStrideAtCompileTime)==int(Dynamic)
109 || int(StrideType::OuterStrideAtCompileTime)==int(Dynamic) || int(StrideType::OuterStrideAtCompileTime)==int(Derived::OuterStrideAtCompileTime),
148 : Base(0,RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime),
149 // Stride<> does not allow default ctor for Dynamic strides, so let' initialize it with dummy values:
150 m_stride(StrideType::OuterStrideAtCompileTime==Dynamic?0:StrideType::OuterStrideAtCompileTime,
151 StrideType::InnerStrideAtCompileTime==Dynamic?0:StrideType::InnerStrideAtCompileTime)
|
| MapBase.h | 134 m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
135 m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime))
139 eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
147 || ( nbRows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == nbRows)
148 && nbCols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == nbCols)));
|
| Visitor.h | 42 struct visitor_impl<Visitor, Derived, Dynamic>
79 enum { unroll = SizeAtCompileTime != Dynamic
80 && CoeffReadCost != Dynamic
81 && (SizeAtCompileTime == 1 || internal::functor_traits<Visitor>::Cost != Dynamic)
85 unroll ? int(SizeAtCompileTime) : Dynamic
|
| /external/eigen/Eigen/src/Core/products/ |
| TriangularSolverVector.h | 38 typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterStride<> > LhsMap;
74 rhs[i] -= (cjLhs.row(i).segment(s,k).transpose().cwiseProduct(Map<const Matrix<RhsScalar,Dynamic,1> >(rhs+s,k))).sum();
92 typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,ColMajor>, 0, OuterStride<> > LhsMap;
117 Map<Matrix<RhsScalar,Dynamic,1> >(rhs+s,r) -= rhs[i] * cjLhs.col(i).segment(s,r);
|
| CoeffBasedProduct.h | 68 && (ColsAtCompileTime == Dynamic
75 && (RowsAtCompileTime == Dynamic
92 CoeffReadCost = InnerSize == Dynamic ? Dynamic
131 Unroll = CoeffReadCost != Dynamic && CoeffReadCost <= EIGEN_UNROLLING_LIMIT,
136 Unroll ? InnerSize-1 : Dynamic,
187 Unroll ? InnerSize-1 : Dynamic,
210 const Diagonal<const LazyCoeffBasedProductType,Dynamic> diagonal(Index index) const
260 struct product_coeff_impl<DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar>
356 struct product_coeff_impl<InnerVectorizedTraversal, Dynamic, Lhs, Rhs, RetScalar
[all...] |
| /external/eigen/test/ |
| diagonalmatrices.cpp | 22 typedef Matrix<Scalar, Rows==Dynamic?Dynamic:2*Rows, Cols==Dynamic?Dynamic:2*Cols> BigMatrix;
99 CALL_SUBTEST_8( diagonalmatrices(Matrix<double,Dynamic,Dynamic,RowMajor>(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
| sparse.h | 58 Matrix<Scalar,Dynamic,Dynamic,Opt1>& refMat,
110 Matrix<Scalar,Dynamic,Dynamic, Opt1>& refMat,
159 Matrix<Scalar,Dynamic,1>& refVec,
183 Matrix<Scalar,1,Dynamic>& refVec,
|
| block.cpp | 40 typedef Matrix<Scalar, Dynamic, Dynamic> DynamicMatrixType;
41 typedef Matrix<Scalar, Dynamic, 1> DynamicVectorType;
79 Matrix<Scalar,Dynamic,Dynamic> b1(1,1); b1(0,0) = m1(r1,c1);
101 Matrix<Scalar,Dynamic,Dynamic> b = m1.template block<BlockRows,BlockCols>(3,3);
104 // same tests with mixed fixed/dynamic size
105 m1.template block<BlockRows,Dynamic>(1,1,BlockRows,BlockCols) *= s1;
106 m1.template block<BlockRows,Dynamic>(1,1,BlockRows,BlockCols)(0,3) = m1.template block<2,5>(1,1)(1,2)
[all...] |
| product_extra.cpp | 16 typedef Matrix<Scalar, 1, Dynamic> RowVectorType;
17 typedef Matrix<Scalar, Dynamic, 1> ColVectorType;
18 typedef Matrix<Scalar, Dynamic, Dynamic,
132 Matrix<float,1,Dynamic,RowMajor,1,5> a(1,4);
133 Matrix<float,Dynamic,Dynamic,ColMajor,5,1> b(4,0);
|
| conservative_resize.cpp | 19 typedef Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic, Storage> MatrixType;
63 typedef Matrix<Scalar, 1, Eigen::Dynamic> VectorType;
107 m.conservativeResizeLike(Matrix<Scalar,Dynamic,Dynamic>::Zero(1,size));
|
| nullary.cpp | 79 Matrix<Scalar,Dynamic,1> row_vector(size);
80 Matrix<Scalar,1,Dynamic> col_vector(size);
85 Matrix<Scalar,Dynamic,1> size_changer(size+50);
|
| product_selfadjoint.cpp | 19 typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, Dynamic, RowMajor> RhsMatrixType;
77 CALL_SUBTEST_7( product_selfadjoint(Matrix<float,Dynamic,Dynamic,RowMajor>(s,s)) );
|
| sparse_vector.cpp | 16 typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
17 typedef Matrix<Scalar,Dynamic,1> DenseVector;
|
| /external/eigen/test/eigen2/ |
| eigen2_submatrices.cpp | 24 Matrix<Scalar, Dynamic, Dynamic> mi = m1.minor(0,0).eval();
80 Matrix<Scalar,Dynamic,Dynamic> b1(1,1); b1(0,0) = m1(r1,c1);
110 Matrix<Scalar,Dynamic,Dynamic> b = m1.template block<BlockRows,BlockCols>(3,3);
|
| eigen2_basicstuff.cpp | 78 if(cols!=1 && rows!=1 && MatrixType::SizeAtCompileTime!=Dynamic)
106 CALL_SUBTEST_7( basicStuff(Matrix<long double,Dynamic,Dynamic>(10,10)) );
|
| /external/eigen/Eigen/src/Core/util/ |
| XprHelper.h | 45 /** \internal If the template parameter Value is Dynamic, this class is just a wrapper around a T variable that
58 template<typename T> class variable_if_dynamic<T, Dynamic>
132 is_dynamic_size_storage = MaxRows==Dynamic || MaxCols==Dynamic,
163 enum { ret = (_Rows==Dynamic || _Cols==Dynamic) ? Dynamic : _Rows * _Cols };
319 // for the purpose of this test, to keep it reasonably simple, we arbitrarily choose a value of Dynamic values.
320 // the choice of 10000 makes it larger than any practical fixed value and even most dynamic values.
326 ScalarReadCostAsInteger = ScalarReadCost == Dynamic ? int(DynamicAsInteger) : int(ScalarReadCost)
[all...] |
| /external/eigen/Eigen/src/Eigen2Support/Geometry/ |
| Hyperplane.h | 25 * \param _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
36 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
41 typedef Matrix<Scalar,int(AmbientDimAtCompileTime)==Dynamic
42 ? Dynamic
49 /** Constructs a dynamic-size hyperplane with \a _dim the dimension
111 inline int dim() const { return int(AmbientDimAtCompileTime)==Dynamic ? m_coeffs.size()-1 : int(AmbientDimAtCompileTime); }
|
| /external/eigen/Eigen/src/Geometry/ |
| Hyperplane.h | 26 * \param _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.
37 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1)
46 typedef Matrix<Scalar,Index(AmbientDimAtCompileTime)==Dynamic
47 ? Dynamic
60 /** Constructs a dynamic-size hyperplane with \a _dim the dimension
122 inline Index dim() const { return AmbientDimAtCompileTime==Dynamic ? m_coeffs.size()-1 : Index(AmbientDimAtCompileTime); }
|
| /external/eigen/Eigen/src/SparseLU/ |
| SparseLU_column_bmod.h | 107 LU_kernel_bmod<Dynamic>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
165 Map<Matrix<Scalar,Dynamic,Dynamic>, 0, OuterStride<> > A( &(glu.lusup.data()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
169 new (&A) Map<Matrix<Scalar,Dynamic,Dynamic>, 0, OuterStride<> > ( &(glu.lusup.data()[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
|
| /external/eigen/bench/ |
| benchEigenSolver.cpp | 81 if (MatrixType::RowsAtCompileTime==Dynamic)
90 if (MatrixType::RowsAtCompileTime==Dynamic)
128 if (MatrixType::RowsAtCompileTime==Dynamic)
201 benchEigenSolver(Matrix<Scalar,Dynamic,Dynamic>(dynsizes[i],dynsizes[i]));
|
| /external/eigen/bench/btl/libs/eigen2/ |
| eigen2_interface.hh | 30 template<class real, int SIZE=Dynamic>
36 enum {IsFixedSize = (SIZE!=Dynamic)};
49 if (SIZE==Dynamic) return "eigen2"; else return "tiny_eigen2";
51 if (SIZE==Dynamic) return "eigen2"; else return "tiny_eigen2";
53 if (SIZE==Dynamic) return "eigen2_novec"; else return "tiny_eigen2_novec";
|
| /external/eigen/unsupported/Eigen/src/Polynomials/ |
| Companion.h | 33 ret = (Size == Dynamic) ? Dynamic : Size-1 };
42 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Deg==Dynamic ? Dynamic : _Deg)
214 EIGEN_STATIC_ASSERT( Deg == Dynamic || 1 < Deg, YOU_MADE_A_PROGRAMMING_MISTAKE );
|
| /external/eigen/Eigen/src/SparseCholesky/ |
| SimplicialCholesky.h | 46 typedef Matrix<Scalar,Dynamic,1> VectorType;
112 const PermutationMatrix<Dynamic,Dynamic,Index>& permutationP() const
117 const PermutationMatrix<Dynamic,Dynamic,Index>& permutationPinv() const
237 PermutationMatrix<Dynamic,Dynamic,Index> m_P; // the permutation
238 PermutationMatrix<Dynamic,Dynamic,Index> m_Pinv; // the inverse permutation
316 typedef Matrix<Scalar,Dynamic,1> VectorType
[all...] |
| /external/eigen/unsupported/Eigen/src/SVD/ |
| SVDBase.h | 87 * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not
217 eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) &&
218 "SVDBase: thin U and V are only available when your matrix has a dynamic number of columns.");
222 if(RowsAtCompileTime==Dynamic)
226 if(ColsAtCompileTime==Dynamic)
|
| /external/eigen/unsupported/test/ |
| sparse_extra.cpp | 59 typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
60 typedef Matrix<Scalar,Dynamic,1> DenseVector;
|
