Struct Problem 

pub struct Problem { /* private fields */ }

Implementations

impl Problem

pub fn new(jacobian_mode: JacobianMode) -> Self

pub fn mark_for_elimination(&mut self, key: VarKey)

Mark a variable to be eliminated by the Schur complement solver.

Nothing is eliminated by default — not even Rn(3) landmarks. A bundle-adjustment problem only uses the Schur path once every landmark carries an explicit mark (or the solver is configured with auto-detection); unmarked variables are retained and form the reduced system. The eliminated set is not restricted to 3-DOF landmarks: any DOF works, sizes may be mixed within one problem, and the eliminated variables need not be adjacent in the variable ordering. That covers inverse-depth parameterizations (1 DOF), LiDAR features, and sliding-window marginalization of whole poses (6 DOF), as well as classic bundle adjustment.

Precondition

Eliminated variables must be mutually unconnected — no factor may touch two of them. That is what makes H_ee block-diagonal and its inverse cheap. Violating it is reported as an error on the first solve, naming both variables, rather than silently producing a wrong step.

pub fn mark_as_schur_landmark(&mut self, key: VarKey)

👎Deprecated since 1.6.0:

renamed to mark_for_elimination: elimination is not restricted to landmarks

Bundle-adjustment-flavoured alias for Self::mark_for_elimination.

pub fn add_variable( &mut self, manifold_type: ManifoldType, params: DVector<f64>, ) -> VarKey

Add a variable with a given manifold type and initial parameter vector.

Returns a stable VarKey handle for use in add_residual_block, fix_variable, etc.

pub fn add_residual_block( &mut self, variable_keys: &[VarKey], factor: Box<dyn Factor + Send + Sync>, loss_func: Option<Box<dyn LossFunction + Send + Sync>>, ) -> FactorKey

Add a residual block (factor + optional loss) connecting the given variables.

Returns a FactorKey that can be used to remove the block later.

pub fn add_residual_block_with_noise( &mut self, variable_keys: &[VarKey], factor: Box<dyn Factor + Send + Sync>, loss_func: Option<Box<dyn LossFunction + Send + Sync>>, noise: NoiseModel, ) -> FactorKey

Register a residual block with a measurement noise model, keeping the validation behaviour of Self::try_add_residual_block.

The model carries the square-root information S; residuals and Jacobians are whitened (S·r, S·J) before the robust-loss corrector, so the optimized objective is Σ ½·ρ(‖S·r‖²) — the Ω-weighted objective g2o-style benchmarks report. Its dimension must equal the factor’s residual_dim().

pub fn try_add_residual_block_with_noise( &mut self, variable_keys: &[VarKey], factor: Box<dyn Factor + Send + Sync>, loss_func: Option<Box<dyn LossFunction + Send + Sync>>, noise: NoiseModel, ) -> CoreResult<FactorKey>

Self::add_residual_block_with_noise returning a typed error.

pub fn try_add_residual_block( &mut self, variable_keys: &[VarKey], factor: Box<dyn Factor + Send + Sync>, loss_func: Option<Box<dyn LossFunction + Send + Sync>>, ) -> CoreResult<FactorKey>

Register a residual block, validating it against the referenced variables first.

Runs the factor’s Factor::validate_variables hook so shape mismatches (e.g. a landmark variable whose parameter count disagrees with the factor’s observations) surface as a typed registration error instead of a panic inside the parallel assembly. Unknown variable keys are rejected as well — they would otherwise be silently skipped during linearization.

pub fn remove_residual_block( &mut self, block_id: FactorKey, ) -> Option<ResidualBlock>

pub fn fix_variable(&mut self, var_key: VarKey, idx: usize)

Hold tangent-space component idx of var_key fixed during solving.

Panics

If the key is unknown or idx is outside the variable’s DOF. Use Self::try_fix_variable to handle that as an error.

pub fn try_fix_variable( &mut self, var_key: VarKey, idx: usize, ) -> CoreResult<()>

Self::fix_variable returning a typed error.

An out-of-range idx used to be accepted and then silently ignored forever, because the constraint is only ever applied by index against a tangent vector that never has that component.

pub fn unfix_variable(&mut self, var_key: VarKey)

pub fn set_variable_bounds( &mut self, var_key: VarKey, idx: usize, lower_bound: f64, upper_bound: f64, )

Constrain tangent-space component idx of var_key to [lower, upper].

Panics

If the key is unknown, idx is outside the variable’s DOF, or the range is inverted. Use Self::try_set_variable_bounds to handle that as an error.

pub fn try_set_variable_bounds( &mut self, var_key: VarKey, idx: usize, lower_bound: f64, upper_bound: f64, ) -> CoreResult<()>

Self::set_variable_bounds returning a typed error.

An inverted range used to be warned about and then dropped, leaving the caller unable to distinguish “bound set” from “bound rejected”.

pub fn remove_variable_bounds(&mut self, var_key: VarKey)

pub fn apply_constraints_to_variables( &self, variables: &mut SlotMap<VarKey, Box<dyn ManifoldVariable>>, )

Apply fixed indices and bounds to a mutable clone of the variable map.

Optimizers call this after copying problem.variables to initialize working state.

pub fn num_residual_blocks(&self) -> usize

pub fn total_residual_dimension(&self) -> usize

Total number of scalar residuals across all residual blocks.

This is the row count m of the assembled Jacobian.

pub fn compute_residual_sparse( &self, variables: &SlotMap<VarKey, Box<dyn ManifoldVariable>>, ) -> CoreResult<Mat<f64>>

Compute only the residual vector (no Jacobian) for the given variable values.

pub fn compute_residual_and_cost_sparse( &self, variables: &SlotMap<VarKey, Box<dyn ManifoldVariable>>, ) -> CoreResult<(Mat<f64>, f64)>

Compute the residual vector together with the objective value.

The cost is not 0.5·‖r‖² of the returned vector. For blocks carrying a robust loss the returned residual is Triggs-corrected — it exists to drive the linear system — while the cost is the true robust cost 0.5·ρ(‖r‖²). Squaring the corrected residual gives a different function, which is what made every reported cost and every trust-region ratio wrong for robust problems.

For blocks with no loss function the two coincide at 0.5·‖r‖².

pub fn compute_residual_and_jacobian_sparse( &self, variables: &SlotMap<VarKey, Box<dyn ManifoldVariable>>, variable_index_map: &SecondaryMap<VarKey, usize>, symbolic_structure: &SymbolicStructure, ) -> CoreResult<(Mat<f64>, SparseColMat<usize, f64>)>

Compute residuals and sparse Jacobian.

pub fn compute_residual_and_jacobian_dense( &self, variables: &SlotMap<VarKey, Box<dyn ManifoldVariable>>, variable_index_map: &SecondaryMap<VarKey, usize>, total_dof: usize, ) -> CoreResult<(Mat<f64>, Mat<f64>)>

Compute residuals and dense Jacobian.

pub fn log_residual_to_file( &self, residual: &DVector<f64>, filename: &str, ) -> Result<(), Error>

pub fn log_sparse_jacobian_to_file( &self, jacobian: &SparseColMat<usize, f64>, filename: &str, ) -> Result<(), Error>

pub fn log_variables_to_file( &self, variables: &SlotMap<VarKey, Box<dyn ManifoldVariable>>, filename: &str, ) -> Result<(), Error>

pub fn compute_and_set_covariances( &self, variables: &mut SlotMap<VarKey, Box<dyn ManifoldVariable>>, options: CovarianceOptions, ) -> Option<SecondaryMap<VarKey, Mat<f64>>>

Compute per-variable covariances at variables and store them on the variables themselves.

This re-linearizes the problem at the given point and inverts a clean H = JᵀJ — no Levenberg-Marquardt damping and no Jacobi scaling, both of which are internal solver details and must not appear in the result. See crate::linalg::covariance.

options selects the factorization algorithm and whether the result is multiplied by the estimated noise variance σ̂² (scaled) or returned as the raw H⁻¹ (unscaled). Optimizers pass their covariance_options here.

Returns None if covariance estimation fails (most commonly a rank-deficient H from unfixed gauge freedom), after logging the reason. Callers that need to handle the failure should use Covariance::compute directly, which returns a typed error.

Trait Implementations

impl Default for Problem

fn default() -> Self

Returns the “default value” for a type.