solvr 0.2.0

Advanced computing library for real-world problem solving - optimization, differential equations, interpolation, statistics, and more
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
64
65
66
67
68
69
70

//! Mixed-integer linear programming trait and types.
use crate::DType;

use super::simplex::{LinProgOptions, LinProgTensorConstraints};
use numr::error::Result;
use numr::ops::{CompareOps, ScalarOps, TensorOps};
use numr::runtime::{Runtime, RuntimeClient};
use numr::tensor::Tensor;

/// Options for mixed-integer linear programming.
#[derive(Debug, Clone)]
pub struct MilpOptions {
    /// Maximum number of nodes to explore in branch-and-bound.
    pub max_nodes: usize,
    /// Tolerance for integer feasibility.
    pub int_tol: f64,
    /// Tolerance for optimality gap.
    pub gap_tol: f64,
    /// Base LP solver options.
    pub lp_options: LinProgOptions,
}

impl Default for MilpOptions {
    fn default() -> Self {
        Self {
            max_nodes: 10000,
            int_tol: 1e-6,
            gap_tol: 1e-4,
            lp_options: LinProgOptions::default(),
        }
    }
}

/// Result from tensor-based mixed-integer linear programming.
#[derive(Debug, Clone)]
pub struct MilpTensorResult<R: Runtime<DType = DType>> {
    /// Optimal solution vector.
    pub x: Tensor<R>,
    /// Optimal objective value.
    pub fun: f64,
    /// Whether optimization succeeded.
    pub success: bool,
    /// Number of nodes explored.
    pub nodes: usize,
    /// Optimality gap (upper_bound - lower_bound) / |upper_bound|.
    pub gap: f64,
    /// Status message.
    pub message: String,
}

/// Algorithmic contract for mixed-integer linear programming.
pub trait MilpAlgorithms<R: Runtime<DType = DType>>:
    TensorOps<R> + ScalarOps<R> + CompareOps<R> + RuntimeClient<R>
{
    /// Solve a mixed-integer linear programming problem using branch-and-bound.
    ///
    /// # Arguments
    ///
    /// * `c` - Objective function coefficients
    /// * `constraints` - Linear constraints
    /// * `integrality` - Tensor of booleans (as f64: 1.0 = integer, 0.0 = continuous)
    /// * `options` - Solver options
    fn milp(
        &self,
        c: &Tensor<R>,
        constraints: &LinProgTensorConstraints<R>,
        integrality: &Tensor<R>,
        options: &MilpOptions,
    ) -> Result<MilpTensorResult<R>>;
}