| /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_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);
|
| block_evaluate_preparer.cc | 53 double** jacobians) {
59 jacobians);
70 jacobians[j] = jacobian_values + *jacobian_block_offset;
77 jacobians[j] = NULL;
|
| block_evaluate_preparer.h | 59 // store the jacobians temporarily.
63 double** jacobians);
69 // individual jacobians are requested, use a pass-through scratch evaluate
|
| 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_;
|
| 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...] |
| 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...] |
| scratch_evaluate_preparer.cc | 61 double** jacobians) {
69 jacobians[j] = NULL;
71 jacobians[j] = jacobian_block_cursor;
|
| compressed_row_jacobian_writer.h | 55 // the cost functions, use scratch space to store the jacobians temporarily
65 double **jacobians,
|
| 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_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...] |
| 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;
|
| 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]));
|
| conditioned_cost_function_test.cc | 56 double** jacobians) const {
58 if (jacobians && *jacobians) {
59 **jacobians = a_;
|
| c_api_test.cc | 114 double** jacobians) {
122 if (jacobians == NULL) {
125 if (jacobians[0] != NULL) {
126 jacobians[0][0] = - x * exp(m * x + c); // dr/dm
128 if (jacobians[1] != NULL) {
129 jacobians[1][0] = - exp(m * x + c); // dr/dc
|
| /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;
|
| curve_fitting.c | 129 double** jacobians) {
137 if (jacobians == NULL) {
140 if (jacobians[0] != NULL) {
141 jacobians[0][0] = - x * exp(m * x + c); /* dr/dm */
143 if (jacobians[1] != NULL) {
144 jacobians[1][0] = - exp(m * x + c); /* dr/dc */
|
| /external/ceres-solver/include/ceres/ |
| normal_prior.h | 67 double** jacobians) const;
|
| conditioned_cost_function.h | 86 double** jacobians) const;
|
| 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] =
|
| autodiff_cost_function.h | 32 // Jacobians computed via automatic differentiation. For more
199 double** jacobians) const {
200 if (!jacobians) {
212 jacobians);
|
