Struct lp_modeler::dsl::problem::LpProblem

pub struct LpProblem {
    pub name: &'static str,
    pub unique_name: String,
    pub objective_type: LpObjective,
    pub obj_expr_arena: Option<LpExpression>,
    pub constraints: Vec<LpConstraint>,
}

Structure used for creating the model and solving a linear problem.

Examples:

use lp_modeler::dsl::*;
use lp_modeler::solvers::{SolverTrait, CbcSolver, Solution};

let ref a = LpInteger::new("a");
let ref b = LpInteger::new("b");
let ref c = LpInteger::new("c");

let mut problem = LpProblem::new("One Problem", LpObjective::Maximize);
problem += 10.0 * a + 20.0 * b;

problem += (500*a + 1200*b + 1500*c).le(10000);
problem += (a + b*2 + c).le(10);
problem += (a).le(b);

let solver = CbcSolver::new();

match solver.run(&problem) {
Ok( solution ) => {
    println!("Status {:?}", solution.status);
        for (name, value) in solution.results.iter() {
            println!("value of {} = {}", name, value);
        }
    },
    Err(msg) => println!("{}", msg),
}

Fields

name: &'static str

unique_name: String

objective_type: LpObjective

obj_expr_arena: Option<LpExpression>

constraints: Vec<LpConstraint>

Implementations

impl LpProblem

pub fn new(name: &'static str, objective: LpObjective) -> LpProblem

Create a new problem

pub fn variables(&self) -> HashMap<String, (usize, usize)>

Trait Implementations

impl AddAssign<LpConstraint> for LpProblem

Add constraints

fn add_assign(&mut self, _rhs: LpConstraint)

Performs the += operation.

impl<T> AddAssign<T> for LpProblem where
    T: Into<LpExpression>, 

Add an expression as an objective function

fn add_assign(&mut self, _rhs: T)

Performs the += operation.

impl Debug for LpProblem

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

Formats the value using the given formatter.

impl LpFileFormat for LpProblem

fn to_lp_file_format(&self) -> String

fn write_lp(&self, file_model: &str) -> Result<()>

impl Problem for LpProblem

fn add_objective_expression(&mut self, expr_arena: &mut LpExpression)

fn add_constraints(&mut self, constraint_expr: &LpConstraint)