Struct copper::Solution

source ·

pub struct Solution(/* private fields */);

Expand description

Assignment for decision variables that satisfies all constraints.

Implementations§

source §

impl Solution

source

pub fn get_values(&self, vs: &[VarId]) -> Vec<i32>

Get assignments for the decision variables provided as a slice.

source

pub fn get_values_array<const N: usize>(&self, vs: &[VarId; N]) -> [i32; N]

Get assignments for the decision variables provided as a reference to an array.

source

pub fn get_values_iter<'a, I>(&'a self, vs: I) -> impl Iterator<Item = i32> + 'a
where I: IntoIterator + 'a, I::Item: Borrow<VarId>,

Get assignments for the provided decision variables.

source

pub fn get_value_binary(&self, v: impl Borrow<VarIdBinary>) -> bool

Get binary assignment for the provided decision variable.

source

pub fn get_values_binary(&self, vs: &[VarIdBinary]) -> Vec<bool>

Get binary assignments for the decision variables provided as a slice.

Examples found in repository ?

examples/pc.rs (line 50)

fn main() {
    // All problem formulations will start with a model object
    let mut m = copper::Model::default();

    // How many monitors do we buy: we need at least one, but not more than three
    let n_monitors = m.new_var(1, 3).unwrap();

    // All monitors cost the same, and each additional monitor provides the same bump to our score
    let monitor_price = 100;
    let monitor_score = 250;

    // Each GPU model has a fixed price, and an associated benchmark score
    let gpu_prices = [150, 250, 500];
    let gpu_scores = [100, 400, 800];

    // We use binary decision variables to represent "do I pick this GPU?"
    let gpus: Vec<_> = m.new_vars_binary(gpu_scores.len()).collect();

    // For each potential GPU, we multiply its price (and score) by whether or not it is selected.
    // The sum of these terms gives us the price and score of the selected GPU.
    let gpu_price = m.sum_iter(gpus.iter().zip(gpu_prices).map(|(x, price)| x.times(price)));
    let gpu_score = m.sum_iter(gpus.iter().zip(gpu_scores).map(|(x, score)| x.times(score)));

    // This expression is the overall price of our build
    let price = m.add(gpu_price, n_monitors.times(monitor_price));

    // We want to maximize this score: how much we'll value this particular build
    let score = m.add(gpu_score, n_monitors.times(monitor_score));

    // Exactly one GPU: we want to run Crysis, but our case must fit under the desk
    let n_gpus = m.sum(&gpus);
    m.equals(n_gpus, 1);

    // Grandma got us some money for our birthday, that will be our budget
    m.less_than_or_equals(price, 600);

    // Let the solver find the assignment that upholds our constraints and maximizes our score
    let solution = m.maximize(score).unwrap();

    // Our optimal build has three monitors and a mid-tier GPU. We even have some left-over cash!
    assert_eq!(solution[n_monitors], 3);
    assert_eq!(solution.get_values_binary(&gpus), vec![false, true, false]);
    assert_eq!(solution[score], 1150);
    assert_eq!(solution[price], 550);
}