| /external/eigen/ |
| eigen3.pc.in | 2 Description: A C++ template library for linear algebra: vectors, matrices, and related algorithms
|
| README.android | 4 Eigen is a C++ template library for linear algebra: matrices, vectors,
|
| /external/skia/gm/ |
| shadertext2.cpp | 70 SkTDArray<LabeledMatrix> matrices; local
71 matrices.append()->fMatrix.reset();
72 matrices.top().fLabel = "Identity";
73 matrices.append()->fMatrix.setScale(1.2f, 0.8f);
74 matrices.top().fLabel = "Scale";
75 matrices.append()->fMatrix.setRotate(10.f);
76 matrices.top().fLabel = "Rotate";
77 matrices.append()->fMatrix.reset();
78 matrices.top().fMatrix.setPerspX(-0.0015f);
79 matrices.top().fMatrix.setPerspY(+0.0015f)
[all...] |
| /external/opencv/cvaux/src/ |
| cvtexture.cpp | 60 double*** matrices; member in struct:CvGLCM
140 newGLCM->matrices = 0;
233 if( (flag == CV_GLCM_GLCM || flag == CV_GLCM_ALL) && (*GLCM)->matrices )
237 if( (*GLCM)->matrices[ matrixLoop ] )
239 cvFree( (*GLCM)->matrices[matrixLoop] );
240 cvFree( (*GLCM)->matrices + matrixLoop );
244 cvFree( &((*GLCM)->matrices) );
283 double*** matrices = 0; local
285 // allocate memory to the matrices
286 CV_CALL( destGLCM->matrices = (double***)cvAlloc( sizeof(matrices[0])*numSteps ))
[all...] |
| cvlevmartrif.cpp | 79 CV_ERROR( CV_StsUnsupportedFormat, "Input parameters must be a matrices" );
96 /* This is for function with 3 projection matrices */
97 /* vector X consists of projection matrices and points3D */
99 /* each projection matrices has 3x4 coeffs */
169 /* Computers project points using 3 projection matrices and points 3D */
171 /* vector X consists of projection matrices and points3D */
172 /* each projection matrices has 3x4 coeffs */
175 /* result of function is projection of N 3D points using 3 projection matrices */
181 /* Fill projection matrices */
194 CV_ERROR( CV_StsUnsupportedFormat, "Input parameters must be a matrices" );
[all...] |
| /external/eigen/Eigen/ |
| IterativeLinearSolvers | 14 * - ConjugateGradient for selfadjoint (hermitian) matrices,
15 * - BiCGSTAB for general square matrices.
19 * - DiagonalPreconditioner - also called JAcobi preconditioner, work very well on diagonal dominant matrices.
|
| Cholesky | 12 * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
|
| SparseCholesky | 11 * This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices.
|
| SVD | 14 * This module provides SVD decomposition for matrices (both real and complex).
|
| /external/eigen/bench/spbench/ |
| spbenchsolver.cpp | 7 cout<< " The matrices for the benchmark should be collected in a folder specified with an environment variable EIGEN_MATRIXDIR \n";
9 cout<< " The matrices are stored using the matrix market coordinate format \n";
32 // Get the location of the test matrices
37 std::cerr << "Please, specify the location of the matrices with -d mat_folder or the environment variable EIGEN_MATRIXDIR \n";
71 // Test the matrices in %EIGEN_MATRIXDIR/real
75 // Test the matrices in %EIGEN_MATRIXDIR/complex
|
| /external/ceres-solver/data/ |
| README.foe | 7 matrices from the MATLAB files and performing matrix multiplication.
|
| /external/eigen/Eigen/src/Core/ |
| Matrix.h | 21 * The %Matrix class is the work-horse for all \em dense (\ref dense "note") matrices and vectors within Eigen.
22 * Vectors are matrices with one column, and row-vectors are matrices with one row.
36 * for vectorization. It defaults to aligning matrices except for fixed sizes that aren't a multiple of the packet size.
54 * You can access elements of vectors and matrices using normal subscripting:
76 * <dd>This %Matrix class handles dense, not sparse matrices and vectors. For sparse matrices and vectors, see the Sparse module.
78 * Dense matrices and vectors are plain usual arrays of coefficients. All the coefficients are stored, in an ordinary contiguous array.
79 * This is unlike Sparse matrices and vectors where the coefficients are stored as a list of nonzero coefficients.</dd>
83 * of coefficients as a fixed-size array, as a class member. This makes sense for very small matrices, typically up to 4x4, sometimes u
[all...] |
| /external/eigen/test/ |
| pastix_support.cpp | 30 // There is no support for selfadjoint matrices with PaStiX.
31 // Complex symmetric matrices should pass though
|
| /external/eigen/doc/ |
| C03_TutorialArrayClass.dox | 70 The parenthesis operator is overloaded to provide write and read access to the coefficients of an array, just as with matrices.
87 Adding and subtracting two arrays is the same as for matrices.
105 First of all, of course you can multiply an array by a scalar, this works in the same way as matrices. Where arrays
106 are fundamentally different from matrices, is when you multiply two together. Matrices interpret
144 apply Matrix operations on arrays, or Array operations on matrices. Thus, if you need to do linear algebraic
145 operations such as matrix multiplication, then you should use matrices; if you need to do coefficient-wise
148 access to all operations regardless of the choice of declaring objects as arrays or as matrices.
158 Mixing matrices and arrays in an expression is forbidden with Eigen. For instance, you cannot add a matrix and
159 array directly; the operands of a \c + operator should either both be matrices or both be arrays. However
[all...] |
| I15_StorageOrders.dox | 5 There are two different storage orders for matrices and two-dimensional arrays: column-major and row-major.
66 Matrices and arrays using one storage order can be assigned to matrices and arrays using the other storage
68 the entries automatically. More generally, row-major and column-major matrices can be mixed in an expression
82 matrices. It may be worthwhile to experiment a bit to find out what is faster for your particular
85 is thus done with column-major matrices. This means that, even though we aim to support column-major and
86 row-major storage orders transparently, the Eigen library may well work best with column-major matrices.
|
| SparseQuickReference.dox | 2 /** \page SparseQuickRefPage Quick reference guide for sparse matrices
17 In this page, we give a quick summary of the main operations available for sparse matrices in the class SparseMatrix. First, it is recommended to read first the introductory tutorial at \ref TutorialSparse. The important point to have in mind when working on sparse matrices is how they are stored :
18 i.e either row major or column major. The default is column major. Most arithmetic operations on sparse matrices will assert that they have the same storage order. Moreover, when interacting with external libraries that are not yet supported by Eigen, it is important to know how to send the required matrix pointers.
21 SparseMatrix is the core class to build and manipulate sparse matrices in Eigen. It takes as template parameters the Scalar type and the storage order, either RowMajor or ColumnMajor. The default is ColumnMajor.
27 The copy constructor and assignment can be used to convert matrices from a storage order to another
89 It is easy to perform arithmetic operations on sparse matrices provided that the dimensions are adequate and that the matrices have the same storage order. Note that the evaluation can always be done in a matrix with a different storage order.
179 \section sparsesubmatrices Sub-matrices
184 sm1.middleRows(start, numRows); // For row major matrices, get a range of numRows row
[all...] |
| I02_HiPerformance.dox | 8 for small fixed size matrices. For large matrices, however, it might be useful to
25 Let's start with the most common primitive: the matrix product of general dense matrices.
29 where A, B, and C are column and/or row major matrices (or sub-matrices),
124 Of course all these remarks hold for all other kind of products involving triangular or selfadjoint matrices.
|
| C01_TutorialMatrixClass.dox | 26 In Eigen, all matrices and vectors are objects of the Matrix template class.
27 Vectors are just a special case of matrices, with either 1 row or 1 column.
59 matrices, with either 1 row or 1 column. The case where they have 1 column is the most common;
74 Of course, Eigen is not limited to matrices whose dimensions are known at compile time.
105 Constructors taking sizes are also available. For matrices, the number of rows is always passed first.
116 In order to offer a uniform API across fixed-size and dynamic-size matrices, it is legal to use these
117 constructors on fixed-size matrices, even if passing the sizes is useless in this case. So this is legal:
133 For matrices, the row index is always passed first. For vectors, just pass one index.
146 is not restricted to vectors, it is also available for general matrices, meaning index-based access
147 in the array of coefficients. This however depends on the matrix's storage order. All Eigen matrices default t
[all...] |
| C00_QuickStartGuide.dox | 48 \section GettingStartedExample2 Example 2: Matrices and vectors
50 Here is another example, which combines matrices with vectors. Concentrate on the left-hand program for now; we will talk about the right-hand program later.
83 Now look back at the second example program. We presented two versions of it. In the version in the left column, the matrix is of type \c MatrixXd which represents matrices of arbitrary size. The version in the right column is similar, except that the matrix is of type \c Matrix3d, which represents matrices of a fixed size (here 3-by-3). Because the type already encodes the size of the matrix, it is not necessary to specify the size in the constructor; compare <tt>MatrixXd m(3,3)</tt> with <tt>Matrix3d m</tt>. Similarly, we have \c VectorXd on the left (arbitrary size) versus \c Vector3d on the right (fixed size). Note that here the coefficients of vector \c v are directly set in the constructor, though the same syntax of the left example could be used too.
85 The use of fixed-size matrices and vectors has two advantages. The compiler emits better (faster) code because it knows the size of the matrices and vectors. Specifying the size in the type also allows for more rigorous checking at compile-time. For instance, the compiler will complain if you try to multiply a \c Matrix4d (a 4-by-4 matrix) with a \c Vector3d (a vector of size 3). However, the use of many types increases compilation time and the size of the executable. The size of the matrix may also not be known at compile-time. A rule of thumb is to use fixed-size matrices for size 4-by-4 and smaller.
|
| /external/chromium_org/third_party/mesa/src/src/glsl/ |
| TODO | 5 also trivial for arrays, matrices, and vectors that are accessed with
|
| /external/chromium_org/third_party/skia/src/gpu/gl/ |
| GrGLUniformManager.h | 65 // matrices are column-major, the first three upload a single matrix, the latter three upload
66 // arrayCount matrices into a uniform array.
69 void setMatrix3fv(UniformHandle, int arrayCount, const GrGLfloat matrices[]) const;
70 void setMatrix4fv(UniformHandle, int arrayCount, const GrGLfloat matrices[]) const;
|
| /external/jmonkeyengine/engine/src/core-data/Common/MatDefs/Shadow/ |
| PostShadowPSSM.vert | 32 // populate the light view matrices array and convert vertex to light viewProj space
|
| /external/mesa3d/src/glsl/ |
| TODO | 5 also trivial for arrays, matrices, and vectors that are accessed with
|
| /external/skia/src/gpu/gl/ |
| GrGLUniformManager.h | 65 // matrices are column-major, the first three upload a single matrix, the latter three upload
66 // arrayCount matrices into a uniform array.
69 void setMatrix3fv(UniformHandle, int arrayCount, const GrGLfloat matrices[]) const;
70 void setMatrix4fv(UniformHandle, int arrayCount, const GrGLfloat matrices[]) const;
|
| /external/eigen/unsupported/test/ |
| matrix_square_root.cpp | 16 // for real matrices, make sure none of the eigenvalues are negative
33 // for complex matrices, any matrix is fine
|
