/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();
|
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. 78 double* residuals, double* jacobian);
|
trust_region_minimizer.h | 55 void EstimateScale(const SparseMatrix& jacobian, double* scale) const; 58 const SparseMatrix* jacobian,
|
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, 82 LinearSolver::Summary ComputeGaussNewtonStep(SparseMatrix* jacobian, 84 void ComputeCauchyPoint(SparseMatrix* jacobian); 85 void ComputeGradient(SparseMatrix* jacobian, const double* residuals); 87 bool ComputeSubspaceModel(SparseMatrix* jacobian); 132 // user has recomputed the Jacobian matrix and new Gauss-Newton
|
corrector.cc | 47 // and the jacobian are scaled by the squareroot of the derivative 113 double* residuals, double* jacobian) { 115 DCHECK(jacobian != NULL); 117 MatrixRef j_ref(jacobian, nrow, ncol);
|
evaluator.h | 51 // squares objective. This insulates the optimizer from issues like Jacobian 73 // This is used for computing the cost, residual and Jacobian for 78 // The residual, gradients and jacobian pointers can be NULL, in 96 CRSMatrix* jacobian); 98 // Build and return a sparse matrix for storing and working with the Jacobian 99 // of the objective function. The jacobian has dimensions 101 // sparse. Since the sparsity pattern of the Jacobian remains constant over 111 // the jacobian for use with CHOLMOD, where as BlockOptimizationProblem 112 // creates a BlockSparseMatrix representation of the jacobian for use in the 117 // 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. 139 vector<int>& col_blocks = *(jacobian->mutable_col_blocks()) 158 CompressedRowSparseMatrix* jacobian = local [all...] |
dogleg_strategy.cc | 78 SparseMatrix* jacobian, 81 CHECK_NOTNULL(jacobian); 85 const int n = jacobian->num_cols(); 120 jacobian->SquaredColumnNorm(diagonal_.data()); 126 ComputeGradient(jacobian, residuals); 127 ComputeCauchyPoint(jacobian); 130 ComputeGaussNewtonStep(jacobian, residuals); 147 if (!ComputeSubspaceModel(jacobian)) { 164 // and all calculations involving the Jacobian have to 167 SparseMatrix* jacobian, [all...] |
evaluator.cc | 111 scoped_ptr<CompressedRowSparseMatrix> jacobian; local 113 jacobian.reset( 135 jacobian.get())) { 140 jacobian->ToCRSMatrix(output_jacobian);
|
levenberg_marquardt_strategy.h | 53 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...] |
evaluator_test.cc | 68 // evaluator into the "local" jacobian. In the tests, the "subset 70 // from these jacobians. Put values in the jacobian that make this 80 MatrixRef jacobian(jacobians[k], 84 jacobian.col(j).setConstant(kFactor * (j + 1)); 99 const double jacobian[200]; member in struct:ceres::internal::ExpectedEvaluation 188 scoped_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian()); 192 ASSERT_EQ(expected_num_rows, jacobian->num_rows()); 193 ASSERT_EQ(expected_num_cols, jacobian->num_cols()); 202 expected_jacobian != NULL ? jacobian.get() : NULL)); 206 jacobian->ToDenseMatrix(&actual_jacobian) 609 double* jacobian = jacobians[0]; local 786 CRSMatrix jacobian; local [all...] |
levenberg_marquardt_strategy.cc | 66 SparseMatrix* jacobian, 69 CHECK_NOTNULL(jacobian); 73 const int num_parameters = jacobian->num_cols(); 79 jacobian->SquaredColumnNorm(diagonal_.data()); 103 // Then x can be found as x = -y, but the inputs jacobian and residuals 106 linear_solver_->Solve(jacobian, residuals, solve_options, step);
|
normal_prior_test.cc | 70 double * jacobian = new double[num_rows * num_cols]; local 74 prior.Evaluate(&x, residuals.data(), &jacobian); 82 MatrixRef J(jacobian, num_rows, num_cols); 87 delete []jacobian;
|
trust_region_minimizer.cc | 77 // of the Jacobian. 78 void TrustRegionMinimizer::EstimateScale(const SparseMatrix& jacobian, 80 jacobian.SquaredColumnNorm(scale); 81 for (int i = 0; i < jacobian.num_cols(); ++i) { 94 const SparseMatrix* jacobian, 121 SparseMatrix* jacobian = CHECK_NOTNULL(options_.jacobian); local 155 // Do initial cost and Jacobian evaluation. 157 if (!evaluator->Evaluate(x.data(), &cost, residuals.data(), NULL, jacobian)) { 158 LOG(WARNING) << "Terminating: Residual and Jacobian evaluation failed." [all...] |
minimizer.h | 83 jacobian = NULL; 119 // Jacobian matrix. The Options struct does not own this pointer. 127 // Object holding the Jacobian matrix. It is assumed that the 131 SparseMatrix* jacobian; member in struct:ceres::internal::Minimizer::Options
|
/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;
|
/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...] |