| /external/ceres-solver/internal/ceres/ |
| residual_block_test.cc | 56 double* residuals,
59 residuals[i] = i;
112 double residuals[3]; local
113 residual_block.Evaluate(&cost, residuals, NULL, scratch);
115 EXPECT_EQ(0.0, residuals[0]);
116 EXPECT_EQ(1.0, residuals[1]);
117 EXPECT_EQ(2.0, residuals[2]);
121 VectorRef(residuals, 3).setConstant(0.0);
137 residual_block.Evaluate(&cost, residuals, jacobian_ptrs, scratch);
139 EXPECT_EQ(0.0, residuals[0])
251 double residuals[3]; local
[all...] |
| corrector_test.cc | 59 double residuals = sqrt(3.0); local
61 double sq_norm = residuals * residuals;
72 residuals * sqrt(kRho[1]) / (1 - kAlpha);
79 c.CorrectJacobian(1.0, 1.0, &residuals, &jacobian);
80 c.CorrectResiduals(1.0, &residuals);
82 ASSERT_NEAR(residuals, kExpectedResidual, 1e-6);
87 double residuals = 0.0; local
89 double sq_norm = residuals * residuals;
115 double residuals = sqrt(3.0); local
146 double residuals[3]; local
214 double residuals[3]; local
[all...] |
| runtime_numeric_diff_cost_function_test.cc | 65 double* residuals,
69 residuals[0] = residuals[1] = residuals[2] = 0;
71 residuals[0] += parameters[0][i] * parameters[1][i];
72 residuals[2] += parameters[1][i] * parameters[1][i];
74 residuals[1] = residuals[0] * residuals[0];
101 double residuals[3] = {-1e-100, -2e-100, -3e-100 } local
197 double residuals[2]; local
[all...] |
| numeric_diff_cost_function_test.cc | 61 double* residuals,
65 residuals[0] = residuals[1] = residuals[2] = 0;
67 residuals[0] += parameters[0][i] * parameters[1][i];
68 residuals[2] += parameters[1][i] * parameters[1][i];
70 residuals[1] = residuals[0] * residuals[0];
81 3, /* number of residuals */
105 double residuals[3] = {-1e-100, -2e-100, -3e-100 }; local
210 double residuals[2]; local
[all...] |
| residual_block_utils_test.cc | 60 double residuals; local
65 &residuals,
71 // valid residuals and jacobians.
75 double* residuals,
77 residuals[0] = 1;
90 double* residuals,
92 // Forget to update the residuals.
93 // residuals[0] = 1;
104 double* residuals,
106 residuals[0] = 1
[all...] |
| residual_block.cc | 64 double* residuals,
71 // residuals taking more than 8 parameter block arguments are rare.
92 // If the caller didn't request residuals, use the scratch space for them.
93 bool outputting_residuals = (residuals != NULL);
95 residuals = scratch;
103 InvalidateEvaluation(*this, cost, residuals, eval_jacobians);
105 if (!cost_function_->Evaluate(parameters.get(), residuals, eval_jacobians)) {
112 residuals,
123 residuals,
129 double squared_norm = VectorRef(residuals, num_residuals).squaredNorm()
[all...] |
| normal_prior_test.cc | 71 Vector residuals(num_rows);
74 prior.Evaluate(&x, residuals.data(), &jacobian);
78 (residuals - A * (VectorRef(x, num_cols) - b)).squaredNorm();
110 Vector residuals(num_rows);
113 prior.Evaluate(&x, residuals.data(), jacobians);
117 (residuals - A * (VectorRef(x, num_cols) - b)).squaredNorm();
120 prior.Evaluate(&x, residuals.data(), NULL);
123 (residuals - A * (VectorRef(x, num_cols) - b)).squaredNorm();
|
| runtime_numeric_diff_cost_function.cc | 96 ResidualVector residuals(num_residuals);
97 if (!function->Evaluate(parameters, &residuals[0], NULL)) {
103 // 1. Store residuals for the forward part.
104 // 2. Subtract residuals for the backward (or 0) part.
106 parameter_jacobian.col(j) = residuals;
113 if (!function->Evaluate(parameters, &residuals[0], NULL)) {
117 parameter_jacobian.col(j) -= residuals;
120 // Forward difference only; reuse existing residuals evaluation.
147 double* residuals,
149 // Get the function value (residuals) at the the point to evaluate
[all...] |
| evaluator_test.cc | 60 double* residuals,
63 residuals[i] = i + 1;
78 // between Jacobians of different residuals for the same parameter.
97 const double residuals[50]; member in struct:ceres::internal::ExpectedEvaluation
182 Vector residuals(num_residuals);
183 residuals.setConstant(-2000);
200 expected_residuals != NULL ? &residuals[0] : NULL,
216 &residuals[0],
228 (i & 1) ? expected.residuals : NULL,
257 // Residuals
661 double residuals[2] = { -2, -2 }; local
671 double residuals[2] = { -2, -2}; local
784 vector<double> residuals; local
[all...] |
| residual_block_utils.cc | 49 double* residuals,
55 InvalidateArray(num_residuals, residuals);
83 double* residuals,
86 CHECK_NOTNULL(residuals);
93 "Residual Block size: %d parameter blocks x %d residuals\n\n",
100 "indicated by 'Uninitialized'. This is an error. Residuals or Jacobian values evaluating \n" // NOLINT
103 string space = "Residuals: ";
105 AppendArrayToString(num_residuals, residuals, &result);
134 double* residuals,
139 if (!IsArrayValid(num_residuals, residuals)) {
[all...] |
| conditioned_cost_function.cc | 44 // This cost function has the same dimensions (parameters, residuals) as
78 double* residuals,
80 bool success = wrapped_cost_function_->Evaluate(parameters, residuals,
88 // residuals[r] = conditioners[r](wrapped_residuals[r])
103 double unconditioned_residual = residuals[r];
106 &residuals[r],
|
| autodiff_cost_function_test.cc | 73 double residuals = 0.0; local
75 cost_function->Evaluate(parameters, &residuals, NULL);
76 EXPECT_EQ(10.0, residuals);
77 cost_function->Evaluate(parameters, &residuals, jacobians);
125 double residuals = 0.0; local
127 cost_function->Evaluate(parameters, &residuals, NULL);
128 EXPECT_EQ(45.0, residuals);
130 cost_function->Evaluate(parameters, &residuals, jacobians);
131 EXPECT_EQ(residuals, 45.0);
|
| corrector.h | 68 // residuals *= sqrt(rho[1]) / (1 - alpha)
69 void CorrectResiduals(int nrow, double* residuals);
72 // sqrt(rho[1]) * alpha / sq_norm * residuals residuals' * jacobian.
78 double* residuals, double* jacobian);
|
| residual_block_utils.h | 57 double* residuals,
60 // Check if any of the arrays cost, residuals or jacobians contains an
65 double* residuals,
69 // value of the parameters, residuals and jacobians if present.
74 double* residuals,
|
| corrector.cc | 105 void Corrector::CorrectResiduals(int nrow, double* residuals) {
106 DCHECK(residuals != NULL);
107 VectorRef r_ref(residuals, nrow);
113 double* residuals, double* jacobian) {
114 DCHECK(residuals != NULL);
116 ConstVectorRef r_ref(residuals, nrow);
|
| evaluator.h | 94 vector<double>* residuals,
117 // residuals, and jacobian in the corresponding arguments. Both residuals and
124 // double, and residuals is an array of doubles of size NumResiduals().
127 double* residuals,
153 // The number of residuals in the optimization problem.
|
| trust_region_minimizer_test.cc | 87 double* residuals,
116 if (residuals != NULL) {
117 residuals[0] = f1;
118 residuals[1] = f2;
119 residuals[2] = f3;
120 residuals[3] = f4;
294 double* residuals,
296 residuals[0] = target_length_;
305 residuals[0] -= sqrt(length);
|
| evaluator.cc | 78 vector<double>* residuals,
103 if (residuals !=NULL) {
104 residuals->resize(evaluator->NumResiduals());
133 residuals != NULL ? &(*residuals)[0] : NULL,
|
| residual_block.h | 72 // components in *residuals, and the jacobians between the parameters and
73 // residuals in jacobians[i], in row-major order. If residuals is NULL, the
74 // residuals are not computed. If jacobians is NULL, no jacobians are
91 double* residuals,
|
| normal_prior.cc | 52 double* residuals,
55 VectorRef r(residuals, num_residuals());
|
| /external/ceres-solver/include/ceres/ |
| autodiff_cost_function.h | 97 // runtime-determined number of residuals. For example:
105 // Actual number of residuals ------+ | | |
106 // Indicate dynamic number of residuals ---------+ | |
145 // If the number of residuals (argument "M" below) is ceres::DYNAMIC, then the
147 // of residuals (in addition to the templated number of residuals). This allows
148 // for varying the number of residuals for a single autodiff cost function at
151 int M, // Number of residuals, or ceres::DYNAMIC.
166 // number of residuals ("M").
170 << "number of residuals is set to ceres::DYNAMIC."
[all...] |
| numeric_diff_cost_function.h | 141 double residuals[num_residuals]; // NOLINT local
142 if (!function->Evaluate(parameters, residuals, NULL)) {
148 // 1. Store residuals for the forward part.
149 // 2. Subtract residuals for the backward (or 0) part.
152 Map<const ResidualVector>(residuals, num_residuals);
159 if (!function->Evaluate(parameters, residuals, NULL)) {
164 Map<ResidualVector>(residuals, num_residuals, 1);
167 // Forward difference only; reuse existing residuals evaluation.
217 double* residuals,
219 // Get the function value (residuals) at the the point to evaluate
[all...] |
| /external/ceres-solver/examples/ |
| snavely_reprojection_error.h | 60 T* residuals) const {
88 residuals[0] = predicted_x - T(observed_x);
89 residuals[1] = predicted_y - T(observed_y);
113 T* residuals) const {
143 residuals[0] = predicted_x - T(observed_x);
144 residuals[1] = predicted_y - T(observed_y);
|
| quadratic.cc | 46 : public SizedCostFunction<1 /* number of residuals */,
51 double* residuals,
56 residuals[0] = 10 - x;
|
| quadratic_numeric_diff.cc | 48 : public SizedCostFunction<1 /* number of residuals */,
53 double* residuals,
58 residuals[0] = 10 - parameters[0][0];
|
