Struct relp::data::linear_program::general_form::GeneralForm

pub struct GeneralForm<F> { /* fields omitted */ }

A linear program in general form.

This structure is used as a first storage independent representation format for different parse results to be transformed to.

Can be checked for consistency by the is_consistent method in this module. That method can be viewed as documentation for the requirements on the variables in this data structure.

Implementations

impl<F: LinearAlgebraElement<F> + SparseComparator> GeneralForm<F>

pub fn new(
    objective: Objective,
    constraints: Sparse<F, F, ColumnMajor>,
    constraint_types: Vec<RangedConstraintRelation<F>>,
    b: DenseVector<F>,
    variables: Vec<Variable<F>>,
    variable_names: Vec<String>,
    fixed_cost: F
) -> Self

Create a new linear program in general form.

Simple constructor except for two indices that get created.

impl<OF: 'static> GeneralForm<OF> where
    OF: OrderedField + LinearAlgebraElement<OF>,
    &'r OF: OrderedFieldRef<OF>, 

pub fn derive_matrix_data(
    &mut self
) -> Result<MatrixData<'_, OF>, LinearProgramType<OF>>

Modify this linear problem such that it is representable by a MatrixData structure.

The problem gets transformed into standard form, which also includes a presolve operation. Note that this call might be expensive.

TODO(ENHANCEMENT): Make sure that presolving can be skipped.

See also the documentation of the GeneralForm::standardize method.

Return value

A Result containing either the MatrixData form of the presolved and standardized problem.

Errors

In case the linear program gets solved during this presolve operation, a solution.

pub fn standardize(&mut self) -> Result<(), LinearProgramType<OF>>

Convert this GeneralForm problem to a form closer to the standard form representation.

This involves:

• Determining which rows and columns can be removed or differently represented to reduce the problem size and increase the reading speed from a MatrixData structure.
• Determining which variables are implicitly fixed, such that their only feasible value can be substituted into the problem and the column eliminated.
• Modifying variables such that they are either free or bounded below by zero (with possibly an upper bound).
• Multiplying some rows such that the constraint value is non-negative.

To do the above, a column major representation of the constraint data is built. This requires copying all constraint data once.

TODO(ENHANCEMENT): Make sure that presolving can be skipped.

Errors

In case the linear program gets solved during this presolve operation, a solution.

pub fn get_solution(&self) -> Option<Solution<OF>>

If this problem is fully solved (probably by presolving), get the solution.

All original variables need to have an explicit solution. Hint: Try calling compute_solution_where_possible.

Return value

If one of the variables is still undetermined, None.

pub fn reshift_solution<G>(&self, reduced_solution: &mut SparseVector<G, G>) where
    G: LinearAlgebraElement<G> + SparseComparator + PartialEq<OF> + AddAssign<OF> + From<OF>,
    &'r OF: Neg<Output = OF>,
    &'r G: Neg<Output = G>, 

Transform a solution back.

When converting the problem to standard form, and during presolving, transformations to variables are applied that need to be undone once a solution was computed.

Arguments

• reduced_solution: Solution values for all variables that are still marked as Active in the “original variables” of this problem.

pub fn compute_full_solution_with_reduced_solution<G>(
    self,
    reduced_solution: SparseVector<G, G>
) -> Solution<G> where
    G: Sum + Neg<Output = G> + AddAssign<OF> + PartialEq<OF> + LinearAlgebraElement<G> + From<OF> + Eq + Ord + Zero,
    G: Add<&'r OF, Output = G>,
    &'r G: Neg<Output = G> + Mul<&'r OF, Output = G> + Add<&'r OF, Output = G> + Sub<&'r G, Output = G>, 

Extend a reduced solution with already known values.

Presolving might have determined variables explicitly or as a function of others. This method augments the solution of the open part of the problem to a complete solution.

Arguments

• reduced_solution: A value for each of the variables in this general form that are still marked as unsolved (in the original_variables field).

Returns

A complete solution.

impl<OF> GeneralForm<OF> where
    OF: LinearAlgebraElement<OF> + SparseComparator, 

pub fn nr_constraints(&self) -> usize

The number of constraints in this linear program.

Return value

The number of constraints, which excludes any variable bounds.

pub fn nr_variables(&self) -> usize

The number of variables in this linear program.

Return value

The number of columns / variables, which includes the slack columns / variables.

Trait Implementations

impl<F: Debug> Debug for GeneralForm<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: PartialEq> PartialEq<GeneralForm<F>> for GeneralForm<F>

fn eq(&self, other: &GeneralForm<F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &GeneralForm<F>) -> bool

This method tests for !=.

impl<FI, FO: From<FI>> TryInto<GeneralForm<FO>> for MPS<FI> where
    FI: Sub<Output = FI> + Abs + Ord + Zero + Display + Clone,
    FO: NotZero + Zero + One + Neg<Output = FO> + Ord + Element,
    FO: Add<&'r FO, Output = FO>,
    &'r FO: Neg<Output = FO>, 

fn try_into(self) -> Result<GeneralForm<FO>, Self::Error>

Convert an MPS into a GeneralForm linear program.

Arguments

• self: MPS instance.

Return value

A linear program in general form.

Errors

TODO(DOCUMENTATION): When can errors occur?

type Error = Inconsistency

The type returned in the event of a conversion error.

impl<F: Eq> Eq for GeneralForm<F>

impl<F> StructuralEq for GeneralForm<F>

impl<F> StructuralPartialEq for GeneralForm<F>