| /external/ceres-solver/internal/ceres/ |
| local_parameterization.cc | 53 double* jacobian) const {
54 MatrixRef(jacobian, size_, size_) = Matrix::Identity(size_, size_);
100 double* jacobian) const {
101 MatrixRef m(jacobian, constancy_mask_.size(), local_size_);
133 double* jacobian) const {
134 jacobian[0] = -x[1]; jacobian[1] = -x[2]; jacobian[2] = -x[3]; // NOLINT
135 jacobian[3] = x[0]; jacobian[4] = x[3]; jacobian[5] = -x[2]; // NOLIN
[all...] |
| block_evaluate_preparer.cc | 49 // Point the jacobian blocks directly into the block sparse matrix.
52 SparseMatrix* jacobian,
54 // If the overall jacobian is not available, use the scratch space.
55 if (jacobian == NULL) {
58 jacobian,
64 down_cast<BlockSparseMatrix*>(jacobian)->mutable_values();
|
| trust_region_minimizer.h | 54 void EstimateScale(const SparseMatrix& jacobian, double* scale) const;
56 const SparseMatrix* jacobian,
|
| block_evaluate_preparer.h | 31 // A evaluate preparer which puts jacobian the evaluated jacobian blocks
33 // The evaluator takes care to avoid evaluating the jacobian for fixed
57 // Point the jacobian blocks directly into the block sparse matrix, if
58 // jacobian is non-null. Otherwise, uses an internal per-thread buffer to
62 SparseMatrix* jacobian,
68 // For the case that the overall jacobian is not available, but the
|
| corrector.h | 42 // to the residual and jacobian of a least squares problem based on a
47 // corresponding corrections to the residual and jacobian. For the
64 // CorrectResidual, because the jacobian correction depends on the
71 // jacobian = sqrt(rho[1]) * jacobian -
72 // sqrt(rho[1]) * alpha / sq_norm * residuals residuals' * jacobian.
74 // The method assumes that the jacobian has row-major storage. It is
76 // jacobian is not null.
80 double* jacobian);
|
| evaluator_test_utils.h | 44 const double jacobian[200]; member in struct:ceres::internal::ExpectedEvaluation
|
| dynamic_autodiff_cost_function_test.cc | 119 // Prepare the jacobian.
123 vector<double*> jacobian; local
124 jacobian.push_back(jacobian_vect[0].data());
125 jacobian.push_back(jacobian_vect[1].data());
127 // Test jacobian computation.
130 jacobian.data()));
138 // Check "A" Jacobian.
140 // Check "B" Jacobian.
146 // Check "C" Jacobian for first parameter block.
155 // Check "C" Jacobian for second parameter block
190 vector<double*> jacobian; local
240 vector<double*> jacobian; local
443 vector<double*> jacobian; local
473 vector<double*> jacobian; local
495 vector<double*> jacobian; local
687 vector<double*> jacobian; local
713 vector<double*> jacobian; local
744 vector<double*> jacobian; local
[all...] |
| corrector.cc | 46 // and the jacobian are scaled by the squareroot of the derivative
115 double* jacobian) {
117 DCHECK(jacobian != NULL);
133 r_transpose_j += jacobian[r * num_cols + c] * residuals[r];
137 jacobian[r * num_cols + c] = sqrt_rho1_ *
138 (jacobian[r * num_cols + c] -
|
| corrector_test.cc | 60 double jacobian = 10.0; local
74 // The jacobian in this case will be
75 // sqrt(kRho[1]) * (1 - kAlpha) * jacobian.
76 const double kExpectedJacobian = sqrt(kRho[1]) * (1 - kAlpha) * jacobian;
79 c.CorrectJacobian(1.0, 1.0, &residuals, &jacobian);
83 ASSERT_NEAR(kExpectedJacobian, jacobian, 1e-6);
88 double jacobian = 10.0; local
102 // The jacobian in this case will be
103 // sqrt(kRho[1]) * jacobian.
104 const double kExpectedJacobian = sqrt(kRho[1]) * jacobian;
116 double jacobian = 10.0; local
147 double jacobian[2 * 3]; local
215 double jacobian[2 * 3]; local
[all...] |
| dogleg_strategy.h | 48 // because the Jacobian is often rank-deficient and in such cases
62 SparseMatrix* jacobian,
84 SparseMatrix* jacobian,
86 void ComputeCauchyPoint(SparseMatrix* jacobian);
87 void ComputeGradient(SparseMatrix* jacobian, const double* residuals);
89 bool ComputeSubspaceModel(SparseMatrix* jacobian);
134 // user has recomputed the Jacobian matrix and new Gauss-Newton
|
| evaluator_test.cc | 69 // evaluator into the "local" jacobian. In the tests, the "subset
71 // from these jacobians. Put values in the jacobian that make this
81 MatrixRef jacobian(jacobians[k],
85 jacobian.col(j).setConstant(kFactor * (j + 1));
130 scoped_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
134 ASSERT_EQ(expected_num_rows, jacobian->num_rows());
135 ASSERT_EQ(expected_num_cols, jacobian->num_cols());
144 expected_jacobian != NULL ? jacobian.get() : NULL));
148 jacobian->ToDenseMatrix(&actual_jacobian);
172 (i & 4) ? expected.jacobian : NULL)
551 double* jacobian = jacobians[0]; local
[all...] |
| evaluator.h | 54 // squares objective. This insulates the optimizer from issues like Jacobian
75 // This is used for computing the cost, residual and Jacobian for
80 // The residual, gradients and jacobian pointers can be NULL, in
98 CRSMatrix* jacobian);
100 // Build and return a sparse matrix for storing and working with the Jacobian
101 // of the objective function. The jacobian has dimensions
103 // sparse. Since the sparsity pattern of the Jacobian remains constant over
113 // the jacobian for use with CHOLMOD, where as BlockOptimizationProblem
114 // creates a BlockSparseMatrix representation of the jacobian for use in the
131 // residuals, and jacobian in the corresponding arguments. Both residuals an
[all...] |
| scratch_evaluate_preparer.h | 33 // care to avoid evaluating the jacobian for fixed parameters.
57 SparseMatrix* jacobian,
61 // Scratch space for the jacobians; each jacobian is packed one after another.
|
| levenberg_marquardt_strategy_test.cc | 114 Matrix jacobian(2, 3);
115 jacobian.setZero();
116 jacobian(0, 0) = 0.0;
117 jacobian(0, 1) = 1.0;
118 jacobian(1, 1) = 1.0;
119 jacobian(0, 2) = 100.0;
123 DenseSparseMatrix dsm(jacobian);
|
| compressed_row_jacobian_writer.cc | 50 // Count the number of jacobian nonzeros.
64 // Allocate storage for the jacobian with some extra space at the end.
65 // Allocate more space than needed to store the jacobian so that when the LM
68 CompressedRowSparseMatrix* jacobian = local
76 int* rows = jacobian->mutable_rows();
77 int* cols = jacobian->mutable_cols();
112 // parameter vector. This code mirrors that in Write(), where jacobian
121 // This is the position in the values array of the jacobian where this
122 // row of the jacobian block should go.
140 vector<int>& col_blocks = *(jacobian->mutable_col_blocks())
159 CompressedRowSparseMatrix* jacobian = local
[all...] |
| levenberg_marquardt_strategy.cc | 67 SparseMatrix* jacobian,
70 CHECK_NOTNULL(jacobian);
74 const int num_parameters = jacobian->num_cols();
80 jacobian->SquaredColumnNorm(diagonal_.data());
104 // Then x can be found as x = -y, but the inputs jacobian and residuals
107 linear_solver_->Solve(jacobian, residuals, solve_options, step);
122 jacobian,
|
| dogleg_strategy.cc | 79 SparseMatrix* jacobian,
82 CHECK_NOTNULL(jacobian);
86 const int n = jacobian->num_cols();
121 jacobian->SquaredColumnNorm(diagonal_.data());
127 ComputeGradient(jacobian, residuals);
128 ComputeCauchyPoint(jacobian);
131 ComputeGaussNewtonStep(per_solve_options, jacobian, residuals);
148 if (!ComputeSubspaceModel(jacobian)) {
165 // and all calculations involving the Jacobian have to
168 SparseMatrix* jacobian,
[all...] |
| autodiff_local_parameterization_test.cc | 65 double jacobian[9]; local
66 parameterization.ComputeJacobian(x, jacobian);
70 EXPECT_EQ(jacobian[k], (i == j) ? 1.0 : 0.0);
117 double jacobian[12]; local
120 parameterization.ComputeJacobian(x, jacobian);
135 EXPECT_TRUE(IsFinite(jacobian[i]));
136 EXPECT_NEAR(jacobian[i], jacobian_ref[i], kTolerance)
137 << "Jacobian mismatch: i = " << i
139 << "\n Actual \n" << ConstMatrixRef(jacobian, 4, 3);
|
| levenberg_marquardt_strategy.h | 54 SparseMatrix* 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;
|
| dense_jacobian_writer.h | 31 // A jacobian writer that writes to dense Eigen matrices.
58 // them over to the larger jacobian later.
72 SparseMatrix* jacobian) {
74 if (jacobian != NULL) {
75 dense_jacobian = down_cast<DenseSparseMatrix*>(jacobian);
82 // Now copy the jacobians for each parameter into the dense jacobian matrix.
|
| local_parameterization_test.cc | 55 double jacobian[9]; local
56 parameterization.ComputeJacobian(x, jacobian);
60 EXPECT_EQ(jacobian[k], (i == j) ? 1.0 : 0.0);
106 double jacobian[4 * 3]; local
107 parameterization.ComputeJacobian(x, jacobian);
113 EXPECT_EQ(jacobian[jacobian_cursor], delta_cursor == k ? 1.0 : 0.0);
118 EXPECT_EQ(jacobian[jacobian_cursor], 0.0);
184 // Autodiff jacobian at delta_x = 0.
188 double jacobian[12]; local
189 param.ComputeJacobian(x, jacobian);
[all...] |
| /external/ceres-solver/include/ceres/ |
| local_parameterization.h | 109 // Jacobian which is needed to compute the Jacobian of f w.r.t delta.
123 // The jacobian of Plus(x, delta) w.r.t delta at delta = 0.
124 virtual bool ComputeJacobian(const double* x, double* jacobian) const = 0;
144 double* jacobian) const;
162 double* jacobian) const;
182 double* jacobian) const;
|
| autodiff_local_parameterization.h | 117 virtual bool ComputeJacobian(const double* x, double* jacobian) const {
129 double* jacobian_ptrs[2] = { NULL, jacobian };
|
| /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...] |
