Trait LpProblem 

pub trait LpProblem<'a>: Sized {
    type Variable: AsVariable;
    type Expression: WriteToLpFileFormat;
    type ConstraintIterator: Iterator<Item = Constraint<Self::Expression>>;
    type VariableIterator: Iterator<Item = Self::Variable>;

    // Required methods
    fn variables(&'a self) -> Self::VariableIterator;
    fn objective(&'a self) -> Self::Expression;
    fn sense(&'a self) -> LpObjective;
    fn constraints(&'a self) -> Self::ConstraintIterator;

    // Provided methods
    fn name(&self) -> &str { ... }
    fn to_lp_file_format(&'a self, f: &mut Formatter<'_>) -> Result { ... }
    fn display_lp(&'a self) -> DisplayedLp<'a, Self>
       where Self: Sized { ... }
    fn to_tmp_file(&'a self) -> Result<NamedTempFile>
       where Self: Sized { ... }
}

Implemented by type that can be formatted as an lp problem

Required Associated Types

type Variable: AsVariable

variable type

type Expression: WriteToLpFileFormat

expression type

type ConstraintIterator: Iterator<Item = Constraint<Self::Expression>>

Iterator over constraints

type VariableIterator: Iterator<Item = Self::Variable>

Iterator over variables

Required Methods

fn variables(&'a self) -> Self::VariableIterator

Variables of the problem

fn objective(&'a self) -> Self::Expression

Target objective function

fn sense(&'a self) -> LpObjective

Whether to maximize or minimize the objective

fn constraints(&'a self) -> Self::ConstraintIterator

List of constraints to apply

Provided Methods

fn name(&self) -> &str

problem name. “lp_solvers_problem” by default

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

Write the problem in the lp file format to the given formatter

fn display_lp(&'a self) -> DisplayedLp<'a, Self>

where Self: Sized,

Return an object whose fmt::Display implementation is the problem in the .lp format

fn to_tmp_file(&'a self) -> Result<NamedTempFile>

where Self: Sized,

Write the problem to a temporary file

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, EXPR: 'a, VAR: 'a> LpProblem<'a> for Problem<EXPR, VAR>

where &'a VAR: AsVariable, &'a EXPR: WriteToLpFileFormat,

type Variable = &'a VAR

type Expression = &'a EXPR

type ConstraintIterator = Box<dyn Iterator<Item = Constraint<&'a EXPR>> + 'a>

type VariableIterator = Iter<'a, VAR>