pub(crate) fn presolve(&mut self) -> Result<(), LinearProgramType<OF>> {
        let Changes {
            b,
            constraints,
            fixed_cost,
            bounds,
            removed_variables,
            constraints_marked_removed,
        } = self.compute_presolve_changes()?;

        let variable_indices_only = removed_variables.iter().map(|&(j, _)| j).collect();
        self.update_values_that_remain(
            b,
            constraints,
            fixed_cost,
            bounds,
            removed_variables,
        );
        self.remove_rows_and_columns(constraints_marked_removed, variable_indices_only);
        debug_assert!(is_consistent(&self));

        self.compute_solution_where_possible();
        self.get_solution()
            .map_or(Ok(()), |solution| Err(LinearProgramType::FiniteOptimum(solution)))
    }
/// Recursively analyse constraints and variable bounds and eliminating or tightning these.
///
/// In order to make the linear program easier to solve, a set of rules is applied. These rules
/// are cheaper than the full simplex algorithm and are aimed at making the program easier to
/// solve by other algorithms.
///
/// A set of queues containing constraint and variable indices are maintained. Each presolve
/// step attempts to apply a presolve rule to either a constraint or variable, as indicated by
/// these indices. After a rules is applied and a change occurred, relevant constraint or
/// variable indices might be added to queues, because a rule might be applicable.
///
/// TODO(ENHANCEMENT): Normalization for numerical stability of floating point types.
///
/// # Return value
///
/// If the linear program gets solved during this presolve operation, a `Result::Err` return
/// value containing the solution.
Recursively analyse constraints and variable bounds and eliminating or tightning these.
In order to make the linear program easier to solve, a set of rules is applied. These rules
are cheaper than the full simplex algorithm and are aimed at making the program easier to
solve by other algorithms.

A set of queues containing constraint and variable indices are maintained. Each presolve
step attempts to apply a presolve rule to either a constraint or variable, as indicated by
these indices. After a rules is applied and a change occurred, relevant constraint or
variable indices might be added to queues, because a rule might be applicable.

Normalization for numerical stability of floating point types.
Recursively analyse constraints and variable bounds and eliminating or tightning these . In order to make the linear program easier to solve a set of rules is applied . These rules are cheaper than the full simplex algorithm and are aimed at making the program easier to solve by other algorithms . A set of queues containing constraint and variable indices are maintained . Each presolve step attempts to apply a presolve rule to either a constraint or variable as indicated by these indices . After a rules is applied and a change occurred relevant constraint or variable indices might be added to queues because a rule might be applicable . Normalization for numerical stability of floating point types .
pub(crate) fn presolve(&mut self) -> Result<(), LinearProgramType<OF>> {
        let Changes {
            b,
            constraints,
            fixed_cost,
            bounds,
            removed_variables,
            constraints_marked_removed,
        } = self.compute_presolve_changes()?;
        let variable_indices_only = removed_variables.iter().map(|&(j, _)| j).collect();
        self.update_values_that_remain(
            b,
            constraints,
            fixed_cost,
            bounds,
            removed_variables,
        );
        self.remove_rows_and_columns(constraints_marked_removed, variable_indices_only);
        debug_assert!(is_consistent(&self));
        self.compute_solution_where_possible();
        self.get_solution()
            .map_or(Ok(()), |solution| Err(LinearProgramType::FiniteOptimum(solution)))
    }
pub ( crate ) fn presolve ( & mut self ) -> Result < ( ) , LinearProgramType < OF > > { let Changes { b , constraints , fixed_cost , bounds , removed_variables , constraints_marked_removed , } = self . compute_presolve_changes ( ) ? ; let variable_indices_only = removed_variables . iter ( ) . map ( | & ( j , _ ) | j ) . collect ( ) ; self . update_values_that_remain ( b , constraints , fixed_cost , bounds , removed_variables , ) ; self . remove_rows_and_columns ( constraints_marked_removed , variable_indices_only ) ; debug_assert ! ( is_consistent ( self ) ) ; self . compute_solution_where_possible ( ) ; self . get_solution ( ) . map_or ( Ok ( ( ) ) , | solution | Err ( LinearProgramType :: FiniteOptimum ( solution ) ) ) }
Recursively analyse constraints and variable bounds and eliminating or tightning these.
Recursively analyse constraints and variable bounds and eliminating or tightning these .
&mut self
&mut self
return value
If the linear program gets solved during this presolve operation, a `Result::Err` return
value containing the solution.
If the linear program gets solved during this presolve operation a ` Result :: Err ` return value containing the solution .