lpsolve 1.0.1

High-level lpsolve wrapper
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! Integer programming example: Knapsack Problem
//!
//! We have a knapsack with capacity 15 and items with different weights and values.
//! Goal: Maximize value while staying within weight capacity.

use lpsolve::prelude::*;

fn main() -> Result<()> {
    println!("=== Knapsack Problem (Integer Programming) ===\n");

    // Items: [weight, value]
    let items = vec![
        ("Book", 4.0, 10.0),
        ("Laptop", 7.0, 15.0),
        ("Water", 3.0, 8.0),
        ("Snacks", 2.0, 6.0),
        ("Camera", 5.0, 12.0),
    ];

    let n = items.len();
    let capacity = 15.0;

    // Extract data
    let values: Vec<f64> = items.iter().map(|(_, _, v)| *v).collect();
    let weights: Vec<f64> = items.iter().map(|(_, w, _)| *w).collect();
    let names: Vec<&str> = items.iter().map(|(n, _, _)| *n).collect();

    // Build using terse API
    let solution = Problem::builder()
        .name("Knapsack Problem")?
        .cols(n as i32)
        .max(&values)
        .le(&weights, capacity)
        .binary_vars(&(1..=n as i32).collect::<Vec<_>>())  // All binary
        .variable_names(&names)?
        .typical_mip()
        .solve()?;

    // Display results
    if solution.is_optimal() {
        println!("✓ Found optimal solution!");
        println!("  Total value: {:.2}", solution.objective_value());
        println!("\n  Items to take:");

        let mut total_weight = 0.0;
        for (i, (name, weight, value)) in items.iter().enumerate() {
            if let Some(take) = solution.variable((i + 1) as i32) {
                if take > 0.5 {  // Binary variable, check if 1
                    println!("    ✓ {} (weight: {}, value: {})", name, weight, value);
                    total_weight += weight;
                }
            }
        }

        println!("\n  Total weight used: {:.2}/{:.2}", total_weight, capacity);
        println!("  Nodes explored: {}", solution.nodes());
        println!("  Time elapsed: {:.4}s", solution.time_elapsed());
    } else {
        println!("✗ Problem status: {:?}", solution.status());
    }

    Ok(())
}