| /external/ceres-solver/internal/ceres/ |
| covariance_impl.cc | 411 CRSMatrix jacobian; local
412 problem_->Evaluate(evaluate_options_, NULL, NULL, NULL, &jacobian);
415 // Construct a compressed column form of the Jacobian.
416 const int num_rows = jacobian.num_rows;
417 const int num_cols = jacobian.num_cols;
418 const int num_nonzeros = jacobian.values.size();
425 transpose_rows[jacobian.cols[idx] + 1] += 1;
433 for (int idx = jacobian.rows[r]; idx < jacobian.rows[r + 1]; ++idx) {
434 const int c = jacobian.cols[idx]
574 CRSMatrix jacobian; local
663 CRSMatrix jacobian; local
[all...] |
| compressed_row_jacobian_writer.cc | 44 const Program* program, CompressedRowSparseMatrix* jacobian) {
47 vector<int>& col_blocks = *(jacobian->mutable_col_blocks());
55 vector<int>& row_blocks = *(jacobian->mutable_row_blocks());
88 // Count the number of jacobian nonzeros.
102 // Allocate storage for the jacobian with some extra space at the end.
103 // Allocate more space than needed to store the jacobian so that when the LM
106 CompressedRowSparseMatrix* jacobian = local
114 int* rows = jacobian->mutable_rows();
115 int* cols = jacobian->mutable_cols();
150 // parameter vector. This code mirrors that in Write(), where jacobian
182 CompressedRowSparseMatrix* jacobian = local
[all...] |
| program_evaluator.h | 32 // and stores the result into a jacobian. The particular type of jacobian is
36 // pointers to the jacobian blocks where the cost function evaluates to.
38 // jacobian blocks in the passed sparse matrix.
55 // SparseMatrix* jacobian,
60 // // Create a jacobian that this writer can write. Same as
69 // // larger sparse jacobian.
73 // SparseMatrix* jacobian);
104 void operator()(SparseMatrix* jacobian, int num_parameters) {}
139 SparseMatrix* jacobian) {
[all...] |
| compressed_row_jacobian_writer.h | 31 // A jacobian writer that directly writes to compressed row sparse matrices.
59 // This function is static so that it is available to other jacobian
61 // (Jacobian writers do not fall under any type hierarchy; they only
65 CompressedRowSparseMatrix* jacobian);
67 // It is necessary to determine the order of the jacobian blocks
71 // before block 2 in the column layout of the jacobian. Thus,
73 // jacobian blocks by their position in the state vector.
75 // This function is static so that it is available to other jacobian
77 // (Jacobian writers do not fall under any type hierarchy; they only
89 // jacobians temporarily then copy them over to the larger jacobian
[all...] |
| normal_prior_test.cc | 70 double * jacobian = new double[num_rows * num_cols]; local
74 prior.Evaluate(&x, residuals.data(), &jacobian);
82 MatrixRef J(jacobian, num_rows, num_cols);
87 delete []jacobian;
|
| covariance_test.cc | 129 const double* jacobian)
130 : jacobian_(jacobian, jacobian + num_residuals * parameter_block_size) {
214 virtual bool ComputeJacobian(const double* x, double* jacobian) const {
215 jacobian[0] = x[0];
216 jacobian[1] = x[1];
239 double jacobian[] = { 1.0, 0.0, 0.0, 1.0}; local
240 problem_.AddResidualBlock(new UnaryCostFunction(2, 2, jacobian), NULL, x);
244 double jacobian[] = { 2.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 2.0 }; local
245 problem_.AddResidualBlock(new UnaryCostFunction(3, 3, jacobian), NULL, y)
249 double jacobian = 5.0; local
629 double jacobian[] = { 1.0, 0.0, 0.0, 1.0}; local
634 double jacobian[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; local
639 double jacobian = 5.0; local
[all...] |
| residual_block_utils_test.cc | 62 double jacobian; local
63 double* jacobians[] = { &jacobian };
|
| parameter_block_test.cc | 71 // Ensure the local parameterization jacobian result is correctly computed.
102 double* jacobian) const {
103 jacobian[0] = *x * 2;
134 // Stops computing the jacobian after the first time.
149 virtual bool ComputeJacobian(const double* x, double* jacobian) const {
151 jacobian[0] = 0;
|
| trust_region_strategy.h | 49 // the jacobian matrix and residual vector.
134 SparseMatrix* jacobian,
|
| dogleg_strategy_test.cc | 77 Matrix jacobian = sqrtD * basis; local
78 jacobian_.reset(new DenseSparseMatrix(jacobian));
82 residual_ = -jacobian * minimum;
105 Matrix jacobian = Ddiag.asDiagonal(); local
106 jacobian_.reset(new DenseSparseMatrix(jacobian));
110 residual_ = -jacobian * minimum;
|
| block_jacobian_writer.cc | 47 // per-parameter jacobian goes where in the overall program jacobian.
63 // are there. This will determine where the F blocks start in the jacobian
64 // matrix. Also compute the number of jacobian blocks.
135 // Create evaluate prepareres that point directly into the final jacobian. This
206 BlockSparseMatrix* jacobian = new BlockSparseMatrix(bs); local
207 CHECK_NOTNULL(jacobian);
208 return jacobian;
|
| trust_region_minimizer.cc | 109 // of the Jacobian.
110 void TrustRegionMinimizer::EstimateScale(const SparseMatrix& jacobian,
112 jacobian.SquaredColumnNorm(scale);
113 for (int i = 0; i < jacobian.num_cols(); ++i) {
132 SparseMatrix* jacobian = CHECK_NOTNULL(options_.jacobian); local
196 // Do initial cost and Jacobian evaluation.
202 jacobian)) {
203 summary->message = "Residual and Jacobian evaluation failed.";
236 EstimateScale(*jacobian, scale.data())
[all...] |
| trust_region_minimizer_test.cc | 53 // indicate which of the four variables/columns of the jacobian are
90 SparseMatrix* jacobian) {
124 if (jacobian != NULL) {
126 dense_jacobian = down_cast<DenseSparseMatrix*>(jacobian);
227 scoped_ptr<SparseMatrix> jacobian(powell_evaluator.CreateJacobian());
234 minimizer_options.jacobian = jacobian.get();
|
| minimizer.h | 113 jacobian = NULL;
168 // Jacobian matrix. The Options struct does not own this pointer.
176 // Object holding the Jacobian matrix. It is assumed that the
180 SparseMatrix* jacobian; member in struct:ceres::internal::Minimizer::Options
|
| coordinate_descent_minimizer.cc | 217 scoped_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
218 CHECK_NOTNULL(jacobian.get());
228 minimizer_options.jacobian = jacobian.get();
|
| residual_block_test.cc | 64 MatrixRef jacobian(jacobians[k],
67 jacobian.setConstant(k);
119 // Verify cost, residual, and jacobian evaluation.
147 // Verify cost, residual, and partial jacobian evaluation.
154 jacobian_ptrs[1] = NULL; // Don't compute the jacobian for y.
179 // evaluator into the "local" jacobian. In the tests, the "subset
181 // from these jacobians. Put values in the jacobian that make this
189 MatrixRef jacobian(jacobians[k],
193 jacobian.col(j).setConstant(j);
258 // Verify cost, residual, and jacobian evaluation
[all...] |
| problem_impl.h | 141 CRSMatrix* jacobian);
182 CRSMatrix* jacobian);
|
| problem.cc | 202 CRSMatrix* jacobian) {
207 jacobian);
|
| problem_impl.cc | 603 CRSMatrix* jacobian) {
607 jacobian == NULL) {
649 // columns of the jacobian, we need to make sure that they are
683 // use a SparseRowCompressedMatrix for the jacobian. This is because
684 // the Evaluator decides the storage for the Jacobian based on the
717 if (jacobian != NULL) {
758 if (jacobian != NULL) {
759 tmp_jacobian->ToCRSMatrix(jacobian);
[all...] |
| problem_test.cc | 1097 CRSMatrix jacobian; local
[all...] |
| /external/eigen/unsupported/Eigen/src/AutoDiff/ |
| AutoDiffVector.h | 73 : m_values(other.values()), m_jacobian(other.jacobian())
77 : m_values(other.values()), m_jacobian(other.jacobian())
84 m_jacobian = other.jacobian();
91 m_jacobian = other.jacobian();
98 inline const JacobianType& jacobian() const { return m_jacobian; } function in class:Eigen::AutoDiffVector
99 inline JacobianType& jacobian() { return m_jacobian; } function in class:Eigen::AutoDiffVector
111 m_jacobian + other.jacobian());
119 m_jacobian += other.jacobian();
133 m_jacobian - other.jacobian());
141 m_jacobian -= other.jacobian();
[all...] |
| /external/ceres-solver/include/ceres/internal/ |
| numeric_diff.h | 95 double *jacobian) {
114 Map<JacobianMatrix> parameter_jacobian(jacobian,
148 // Compute this column of the jacobian in 3 steps:
196 double *jacobian) {
|
| /external/ceres-solver/include/ceres/ |
| problem.h | 289 // ordering, rendering the jacobian or residuals returned from the solver
290 // uninterpretable. If you depend on the evaluated jacobian, do not use
300 // ordering, rendering the jacobian or residuals returned from the solver
301 // uninterpretable. If you depend on the evaluated jacobian, do not use
391 // jacobian matrix. If parameter_blocks is empty, then it is
406 // jacobian are ordered. If residual_blocks is empty, then it is
450 // the gradient vector (and the number of columns in the jacobian)
454 // columns in the jacobian).
459 CRSMatrix* jacobian);
|
| /external/opencv/cv/src/ |
| cvcalibration.cpp | 487 cvRodrigues2( const CvMat* src, CvMat* dst, CvMat* jacobian )
516 if( jacobian )
518 if( !CV_IS_MAT(jacobian) )
519 CV_ERROR( CV_StsBadArg, "Jacobian is not a valid matrix" );
521 if( !CV_ARE_DEPTHS_EQ(src, jacobian) || CV_MAT_CN(jacobian->type) != 1 )
522 CV_ERROR( CV_StsUnmatchedFormats, "Jacobian must have 32fC1 or 64fC1 datatype" );
524 if( (jacobian->rows != 9 || jacobian->cols != 3) &&
525 (jacobian->rows != 3 || jacobian->cols != 9)
[all...] |
| /external/eigen/unsupported/Eigen/src/LevenbergMarquardt/ |
| LevenbergMarquardt.h | 177 /** \returns a reference to the diagonal of the jacobian */
186 /** \returns the number of jacobian evaluation */
202 /** \returns a reference to the matrix where the current Jacobian matrix is stored
204 JacobianType& jacobian() {return m_fjac; } function in class:Eigen::LevenbergMarquardt
206 /** \returns a reference to the triangular matrix R from the QR of the jacobian matrix.
207 * \sa jacobian()
231 JacobianType m_rfactor; // The triangular matrix R from the QR of the jacobian matrix m_fjac
283 //FIXME Sparse Case : Allocate space for the jacobian
|
