Hi,

I was wondering how I can set the verbosity level of coin_cbc through this crate. I found https://github.com/KardinalAI/coin_cbc/issues/3 which looks to be what I want. I also saw that I can get an &Model from CoinCbcProblem::as_inner(). The problem is that Model::set_parameter() requires an &mut reference while I can only obtain an immutable one.

Is there a different solution which I missed? If not, maybe a second method could be added to CoinCbcProblem for getting a mutable reference? If this could prove hazardous for upkeeping internal invariants, making this method unsafe would seem like a good compromise to me.

Problem

To implement a function Fn -> Result, the user has to constrain SolverModel::Error struct to 'static + std::error::Error (see example below), which is quite inconvenient and confusing at first (same problem if using anyhow).

Implementation

This PR simply adds those constraints to the Error type definition so that the user can dispense with that verbose constraint. There may be a reason why this wasn't like that, but I don't see it. If that's the case, please disregard and close this PR.

Example

Before this PR:

use good_lp::{default_solver, Solver, variables, SolverModel, Solution, constraint};

fn solve_example<S>(solver: S) -> Result<(), Box<dyn std::error::Error>>
where
    S: Solver,
    // Here
    <<S as good_lp::Solver>::Model as good_lp::SolverModel>::Error: 'static + std::error::Error
{
    variables!{
        vars:
               a <= 1;
          2 <= b <= 4;
    };
    let solution = vars.maximise(10 * (a - b / 5) - b)
        .using(solver)
        .with(constraint!(a + 2 <= b))
        .with(constraint!(1 + a >= 4 - b))
        .solve()?;
    println!("a={}   b={}", solution.value(a), solution.value(b));
    Ok(())
}

fn main() {
    solve_example(default_solver);
}

After this PR:

fn solve_example<S: Solver>(solver: S) -> Result<(), Box<dyn std::error::Error>> {
    variables!{
        vars:
               a <= 1;
          2 <= b <= 4;
    };
    let solution = vars.maximise(10 * (a - b / 5) - b)
        .using(solver)
        .with(constraint!(a + 2 <= b))
        .with(constraint!(1 + a >= 4 - b))
        .solve()?;
    println!("a={}   b={}", solution.value(a), solution.value(b));
    Ok(())
}

By the way, there is a typo in the use "contraint" at the example in the README.

Given this code, where batt_var.b_energy: Vec<Vec<Variable>>:

        for (bat, b_energy_row) in batt_var.b_energy.iter().enumerate() {
            for (t, b_energy) in b_energy_row.iter().enumerate() {
                let mut energy_init: Expression = match bat {
                    0 => b_energy.clone(),
                    1 => Expression::from_other_affine(st_soc * e_max / 100.0),
                    _ => Expression::from_other_affine(b_energy_row[t-1]),
                };
                let bat_pc = Expression::from_other_affine(batt_var.bat_pc[bat][t]);
                energy_init.mul(bat_pc);
            }
        }

I get the following error output:

error[E0277]: the trait bound `f64: From<Expression>` is not satisfied
   --> src/model/constr.rs:449:51
    |
449 |                 energy_init.mul(bat_pc);
    |                                         --- ^^^^^^ the trait `From<Expression>` is not implemented for `f64`
    |                                         |
    |                                         required by a bound introduced by this call
    |

Update:

I have fixed my issue, but I am keeping this because it seems strange.

Thanks for this great library! I have my use-case almost perfect except for one spot.

I have created two vectors of bool variables like so:

let team1_bools = vars.add_vector(variable().binary(), num_players);
let team2_bools = vars.add_vector(variable().binary(), num_players);

later on in my program, I try to count the number of bool values used, and add it in as a constraint:

model = model.with(constraint!(team2_bools.iter().sum() == 5))

when that didn't work, I tried to use this instead:

model = model.with(constraint!(team2_bools.iter().filter(|x| x == 1).count() == 5))

no matter what I try, I always end up with my errors looking like this:

error[E0277]: can't compare `&&good_lp::variable::Variable` with `{integer}`
   --> src/main.rs:147:31
    |
147 |                 .filter(|x| x == 1)
    |                               ^^ no implementation for `&&good_lp::variable::Variable == {integer}`
    |
    = help: the trait `std::cmp::PartialEq<{integer}>` is not implemented for `&&good_lp::variable::Variable`

error[E0271]: type mismatch resolving `<usize as std::ops::Sub>::Output == good_lp::expression::Expression`
   --> src/main.rs:144:24
    |
144 |       model = model.with(constraint!(
    |  ________________________^
145 | |                 team2_bools
146 | |                 .iter()
147 | |                 .filter(|x| x == 1)
148 | |                 .count() == 5));
    | |______________________________^ expected struct `good_lp::expression::Expression`, found `usize`
    | 
   ::: /home/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/good_lp-1.1.3/src/constraint.rs:42:24
    |
42  |   pub fn eq<B, A: Sub<B, Output = Expression>>(a: A, b: B) -> Constraint {
    |                          ------------------- required by this bound in `good_lp::constraint::eq`

I currently have my algorithm working using another library in Python here. I just really want to use rust for the increased speed.

Is there any possible way I would be able to do something like this? Thanks!

Quick side note: this crate is awesome!

One problem I am running into is that I want to create an f64 variable that lies within the domain of all real numbers. How can I achieve this?

This is what I am currently trying to do, but it does not compile due to From<bool> is not implemented for f64.

use std::error::Error;

use good_lp::{constraint, coin_cbc, SolverModel, variables};

fn main() -> Result<(), Box<dyn Error>> {
    let INF: f32 = f32::INFINITY;
    let NEG_INF: f32 = f32::NEG_INFINITY; 

    variables! {
        vars:
            NEG_INF <= x1 <= INF;
            NEG_INF <= x2 <= INF;
    }
    let _solution = vars.minimise(2 * x1 + 3 * x2)
        .using(coin_cbc)
        .with(constraint!((3 * x1) + (4 * x2) >= 1))
        .solve()?;

    Ok(())
}

Edit: I can specify either a lower or upper bound but not both; I am wondering if this is suitable for this situation.

Hi,

I was trying to input a linear program using matrix format, i.e., with constraints in the form of Ax = b. I constructed a COO matrix A but cannot multiply it with the variable x. I get the following error "cannot multiply numopt::matrix::coo::CooMat<f64> by good_lp::Variable". Do you have any more complicated examples where the input is a matrix? Below is my code.

fn main() -> Result<(), Box<dyn Error>> {
        let x = arr1(&[1.0]);
        let c = arr1(&[1.0]); 
        let b = arr1(&[10.0]);
        let u = arr1(&[15.0]);
        let l = arr1(&[-15.0]);
        let p = vec![false ];
        let A: CooMat<f64> = CooMat::<f64>::new(
            (1 , 1 ),
            vec![0],
            vec![0],
            vec![1.0]
        );
        variables! {
            vars:
                   a <= x;
        } // variables can also be added dynamically
        let solution = vars.maximise(  &a  )
            .using(default_solver) // multiple solvers available
            .with(constraint!( A * a == 5))
            .solve()?;
        println!("a={}   b={}", solution.value(a), solution.value(b));
        println!("a + b = {}", solution.eval(a + b));
        Ok(())
    }
}

Thank you for your help!

I tried to set time limit option but I found there is no way to call highs::Model::set_option.

With good_lp API the only chance I can get an instance of highs::Model is to call good_lp::solvers::highs::HighsProblem::into_inner as solve does internally.

https://github.com/rust-or/good_lp/blob/65b4018726ca966fb97ec781eac7178e8f9b8f44/src/solvers/highs.rs#L65

Then I can have several set_option calls and at the end solve method call. Even though I still cannot have HighsSolution instance as solution: highs::Solution field is private and HighsSolution does not have any explicit constructor like new method.

https://github.com/rust-or/good_lp/blob/65b4018726ca966fb97ec781eac7178e8f9b8f44/src/solvers/highs.rs#L126

Can you give me any suggestion to simultaneously use good_lp API as well as set Highs options?

Thank you.

I'm trying to build a sum based on binary variables and coefficients, but the resulting expression doesn't seem to be correct.

let weights = vec![1.1, 1.2, 1.0, 0.9];
let mut vars = variables!();

let xs = vars.add_vector(variable().binary(), weights.len());

let objective = Expression::sum((0..weights.len()).iter().map(|i| xs[i].mul(weights[i])));

I would expect the xs variables to interpreted as ones or zeroes in the sum, i.e., the objective being the sum of the weights of the variables set to 1. However, it appears that the objective is capped at a value smaller than the sum of the weights.

I added an API to set HiGHS options to the HighsProblem struct. This solves #18 .

Currently the API is not safe enough, we can still add invalid key and value type. For example set_option("time_limit".to_string(), 10) will panic when solve method is called. Perhaps I should add explicit APIs like set_time_limit(value: f64). What do you think?

I am using good_lp (at the moment with minilp). I am interested in exact solutions for rational numbers, and therefore I would like to experiment with relp. This is a request to add relp, or guide me doing so.

If I understand correctly, a new "type" of good_lp::variable::VariableDefinition (other than the existing types "continuous" and "integer") would be required. Generally, I am not sure how to deal with the discrepancy of f64 vs. the number types in relp_num which relp uses.

SCIP is one of the commonly-used MI(N)LP solvers and could be of interest to the rust-or communities (free and source available for academic use).

I'd be willing to help add it to lp-solvers if this is the appropriate repository