HomeSort by relevance Sort by last modified time
    Searched full:jacobians (Results 1 - 25 of 86) sorted by null

1 2 3 4

  /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]);
68 double** jacobians) {
102 (jacobians != NULL && jacobians[i] != NULL)
103 ? jacobians[i] + k * parameter_block_size + j
119 double** jacobians) {
127 if (jacobians != NULL) {
130 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...]
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;
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/
cost_function.h 83 // jacobians is an array of size parameter_block_sizes_ containing
86 // parameter_block_sizes, i.e. jacobians[i], is an
90 // jacobians[i][r*parameter_block_size_[i] + c] =
93 // If jacobians is NULL, then no derivatives are returned; this is
94 // the case when computing cost only. If jacobians[i] is NULL, then
99 // residuals and/or jacobians was successful or not.
117 double** jacobians) const = 0;
dynamic_autodiff_cost_function.h 96 double** jacobians) const {
101 if (jacobians == NULL) {
115 // jacobians in a series of passes, each one computing Stripe *
143 if (jacobians[i] != NULL) {
199 if (jacobians[i] != NULL) {
215 // Copy the pieces of the jacobians into their final place.
228 if (jacobians[i] != NULL) {
230 jacobians[i][k * parameter_block_sizes()[i] + j] =
dynamic_numeric_diff_cost_function.h 102 double** jacobians) const {
113 if (jacobians == NULL || !status) {
135 if (jacobians[block] != NULL &&
141 jacobians)) {
154 double** jacobians) const {
166 Map<JacobianMatrix> parameter_jacobian(jacobians[parameter_block],
  /external/apache-commons-math/src/main/java/org/apache/commons/math/ode/jacobians/
StepHandlerWithJacobians.java 18 package org.apache.commons.math.ode.jacobians;
40 * see the original state, and its jacobians in separate arrays.</p>
50 * <p>Dealing with low level step handlers is cumbersome if one really needs the jacobians
52 * state and jacobians on one side and compound state on the other side. So for performance
53 * reasons, it is recommended to use this interface <em>only</em> if jacobians are really

Completed in 300 milliseconds

1 2 3 4