| /external/ceres-solver/internal/ceres/ |
| residual_block_utils_test.cc | 63 double* jacobians[] = { &jacobian }; local
68 jacobians,
73 // valid residuals and jacobians.
78 double** jacobians) const {
80 if (jacobians != NULL && jacobians[0] != NULL) {
81 jacobians[0][0] = 0.0;
93 double** jacobians) const {
96 if (jacobians != NULL && jacobians[0] != NULL)
[all...] |
| autodiff_cost_function_test.cc | 69 double** jacobians = new double*[2]; local
70 jacobians[0] = new double[2];
71 jacobians[1] = new double[2];
77 cost_function->Evaluate(parameters, &residuals, jacobians);
79 EXPECT_EQ(3, jacobians[0][0]);
80 EXPECT_EQ(4, jacobians[0][1]);
81 EXPECT_EQ(1, jacobians[1][0]);
82 EXPECT_EQ(2, jacobians[1][1]);
84 delete[] jacobians[0];
85 delete[] jacobians[1]
118 double** jacobians = new double*[10]; local
[all...] |
| residual_block.cc | 70 double** jacobians,
84 if (jacobians != NULL) {
87 if (jacobians[i] != NULL &&
92 global_jacobians[i] = jacobians[i];
106 double** eval_jacobians = (jacobians != NULL) ? global_jacobians.get() : NULL;
123 "residual and jacobians that were requested or there was a non-finite value (nan/infinite)\n" // NOLINT
136 // Update the jacobians with the local parameterizations.
137 if (jacobians != NULL) {
139 if (jacobians[i] != NULL) {
142 // Apply local reparameterization to the jacobians
[all...] |
| conditioned_cost_function.cc | 79 double** jacobians) const {
81 jacobians);
90 // jacobians[i][r*parameter_block_size_[i] + c] =
99 if (!jacobians) {
112 if (jacobians) {
116 if (jacobians[i]) {
119 VectorRef jacobian_row(jacobians[i] + r * parameter_block_size,
|
| residual_block_utils.cc | 50 double** jacobians) {
56 if (jacobians != NULL) {
59 InvalidateArray(num_residuals * parameter_block_size, jacobians[i]);
86 double** jacobians) {
120 (jacobians != NULL && jacobians[i] != NULL)
121 ? jacobians[i] + k * parameter_block_size + j
137 double** jacobians) {
145 if (jacobians != NULL) {
148 if (!IsArrayValid(num_residuals * parameter_block_size, jacobians[i]))
[all...] |
| block_evaluate_preparer.cc | 53 double** jacobians) {
59 jacobians);
70 jacobians[j] = jacobian_values + *jacobian_block_offset;
77 jacobians[j] = NULL;
|
| normal_prior.cc | 53 double** jacobians) const {
60 if ((jacobians != NULL) && (jacobians[0] != NULL)) {
61 MatrixRef(jacobians[0], num_residuals(), parameter_block_sizes()[0]) = A_;
|
| scratch_evaluate_preparer.h | 31 // A scratch evaluate preparer provides temporary storage for the jacobians that
58 double** jacobians);
61 // Scratch space for the jacobians; each jacobian is packed one after another.
62 // There is enough scratch to hold all the jacobians for the largest residual.
|
| gradient_checker_test.cc | 74 double** jacobians) const {
88 if (jacobians) {
90 if (jacobians[j]) {
93 jacobians[j][u] = - f * a_[j][u];
127 double** jacobians) const {
141 if (jacobians) {
143 if (jacobians[j]) {
146 jacobians[j][u] = - f * a_[j][u] + 0.001;
|
| gradient_checking_cost_function_test.cc | 90 double** jacobians) const {
104 if (jacobians) {
106 if (jacobians[j]) {
109 jacobians[j][u] = - f * a_[j][u];
117 jacobians[j][u] += 500;
151 vector<double*> jacobians(arity);
154 // Since residual is one dimensional the jacobians have the same
156 jacobians[j] = new double[dim[j]];
175 &jacobians[0]);
180 EXPECT_EQ(original_jacobians[j][k], jacobians[j][k])
[all...] |
| residual_block_utils.h | 58 double** jacobians);
60 // Check if any of the arrays cost, residuals or jacobians contains an
66 double** jacobians);
69 // value of the parameters, residuals and jacobians if present.
75 double** jacobians);
|
| residual_block.h | 78 // components in *residuals, and the jacobians between the parameters and
79 // residuals in jacobians[i], in row-major order. If residuals is NULL, the
80 // residuals are not computed. If jacobians is NULL, no jacobians are
81 // computed. If jacobians[i] is NULL, then the jacobian for that parameter is
92 // The returned cost and jacobians have had robustification and local
102 double** jacobians,
|
| block_evaluate_preparer.h | 59 // store the jacobians temporarily.
63 double** jacobians);
69 // individual jacobians are requested, use a pass-through scratch evaluate
|
| scratch_evaluate_preparer.cc | 61 double** jacobians) {
69 jacobians[j] = NULL;
71 jacobians[j] = jacobian_block_cursor;
|
| conditioned_cost_function_test.cc | 56 double** jacobians) const {
58 if (jacobians && *jacobians) {
59 **jacobians = a_;
|
| dense_jacobian_writer.h | 57 // functions, use scratch space to store the jacobians temporarily then copy
71 double **jacobians,
82 // Now copy the jacobians for each parameter into the dense jacobian matrix.
92 ConstMatrixRef parameter_jacobian(jacobians[j],
|
| normal_prior_test.cc | 81 // Compare the jacobians
107 double* jacobians[1]; local
108 jacobians[0] = NULL;
113 prior.Evaluate(&x, residuals.data(), jacobians);
|
| residual_block_test.cc | 57 double** jacobians) const {
61 if (jacobians) {
63 if (jacobians[k] != NULL) {
64 MatrixRef jacobian(jacobians[k],
172 double** jacobians) const {
176 if (jacobians) {
178 // The jacobians here are full sized, but they are transformed in the
181 // from these jacobians. Put values in the jacobian that make this
182 // obvious; in particular, make the jacobians like this:
188 if (jacobians[k] != NULL)
[all...] |
| runtime_numeric_diff_cost_function_test.cc | 66 double** jacobians) const {
67 (void) jacobians; // Ignored.
99 double *jacobians[2] = { &dydx1[0], &dydx2[0] }; local
105 &jacobians[0]));
139 double** jacobians) const {
140 (void) jacobians; // Ignored.
195 double *jacobians[2] = { &dydx1[0], &dydx2[0] }; local
201 &jacobians[0]));
|
| runtime_numeric_diff_cost_function.cc | 54 double** jacobians) {
66 Map<JacobianMatrix> parameter_jacobian(jacobians[parameter_block],
148 double** jacobians) const {
155 if (!jacobians) {
181 if (!jacobians[block]) {
192 jacobians)) {
|
| autodiff_test.cc | 196 double *jacobians[] = { J_PX }; local
198 b, parameters, 2, ad_x1, jacobians)));
211 double *jacobians[] = { J_P, J_X }; local
213 b, parameters, 2, ad_x2, jacobians)));
219 // Now compare the jacobians we got.
318 double *jacobians[] = { J_q, J_c, J_X }; local
320 b, parameters, 2, ad_x, jacobians)));
358 double *jacobians[] = { J_x }; local
370 functor, parameters, num_residuals, residuals, jacobians)));
520 double* jacobians[10] local
[all...] |
| /external/ceres-solver/examples/ |
| helloworld_analytic_diff.cc | 55 double** jacobians) const {
63 // jacobians.
65 // Since the Evaluate function can be called with the jacobians
67 // if jacobians need to be computed.
69 // For this simple problem it is overkill to check if jacobians[0]
73 if (jacobians != NULL && jacobians[0] != NULL) {
74 jacobians[0][0] = -1;
|
| quadratic.cc | 52 double** jacobians) const {
60 // jacobians.
61 if (jacobians != NULL && jacobians[0] != NULL) {
62 jacobians[0][0] = -1;
|
| /external/ceres-solver/include/ceres/ |
| cost_function.h | 82 // jacobians is an array of size parameter_block_sizes_ containing
85 // parameter_block_sizes, i.e. jacobians[i], is an
89 // jacobians[i][r*parameter_block_size_[i] + c] =
92 // If jacobians is NULL, then no derivatives are returned; this is
93 // the case when computing cost only. If jacobians[i] is NULL, then
98 // residuals and/or jacobians was successful or not.
116 double** jacobians) const = 0;
|
| dynamic_autodiff_cost_function.h | 95 double** jacobians) const {
100 if (jacobians == NULL) {
114 // jacobians in a series of passes, each one computing Stripe *
142 if (jacobians[i] != NULL) {
198 if (jacobians[i] != NULL) {
214 // Copy the pieces of the jacobians into their final place.
227 if (jacobians[i] != NULL) {
229 jacobians[i][k * parameter_block_sizes()[i] + j] =
|
