Struct ILP 

pub struct ILP {
    pub num_vars: usize,
    pub bounds: Vec<VarBounds>,
    pub constraints: Vec<LinearConstraint>,
    pub objective: Vec<(usize, f64)>,
    pub sense: ObjectiveSense,
}

Integer Linear Programming (ILP) problem.

An ILP consists of:

• A set of integer variables with bounds
• Linear constraints on those variables
• A linear objective function to optimize
• An optimization sense (maximize or minimize)

Example

use problemreductions::models::optimization::{ILP, VarBounds, Comparison, LinearConstraint, ObjectiveSense};
use problemreductions::Problem;

// Create a simple ILP: maximize x0 + 2*x1
// subject to: x0 + x1 <= 3, x0, x1 binary
let ilp = ILP::new(
    2,
    vec![VarBounds::binary(), VarBounds::binary()],
    vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 3.0)],
    vec![(0, 1.0), (1, 2.0)],
    ObjectiveSense::Maximize,
);

assert_eq!(ilp.num_variables(), 2);

Fields

num_vars: usize

Number of variables.

bounds: Vec<VarBounds>

Bounds for each variable.

constraints: Vec<LinearConstraint>

Linear constraints.

objective: Vec<(usize, f64)>

Sparse objective coefficients: (var_index, coefficient).

sense: ObjectiveSense

Optimization direction.

Implementations

impl ILP

pub fn new( num_vars: usize, bounds: Vec<VarBounds>, constraints: Vec<LinearConstraint>, objective: Vec<(usize, f64)>, sense: ObjectiveSense, ) -> Self

Create a new ILP problem.

Arguments

• num_vars - Number of variables
• bounds - Bounds for each variable (must have length num_vars)
• constraints - List of linear constraints
• objective - Sparse objective coefficients
• sense - Maximize or minimize

Panics

Panics if bounds.len() != num_vars.

pub fn binary( num_vars: usize, constraints: Vec<LinearConstraint>, objective: Vec<(usize, f64)>, sense: ObjectiveSense, ) -> Self

Create a binary ILP (all variables are 0-1).

This is a convenience constructor for common binary optimization problems.

pub fn empty() -> Self

Create an empty ILP with no variables.

pub fn evaluate_objective(&self, values: &[i64]) -> f64

Evaluate the objective function for given variable values.

pub fn bounds_satisfied(&self, values: &[i64]) -> bool

Check if all bounds are satisfied for given variable values.

pub fn constraints_satisfied(&self, values: &[i64]) -> bool

Check if all constraints are satisfied for given variable values.

pub fn is_feasible(&self, values: &[i64]) -> bool

Check if a solution is feasible (satisfies bounds and constraints).

Trait Implementations

impl Clone for ILP

fn clone(&self) -> ILP

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ILP

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ILP

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Problem for ILP

const NAME: &'static str = "ILP"

Base name of this problem type (e.g., “IndependentSet”).

type GraphType = SimpleGraph

The graph type this problem operates on.

type Weight = f64

The weight type for this problem.

type Size = f64

The type used for objective/size values.

fn num_variables(&self) -> usize

Returns the number of variables in the problem.

fn num_flavors(&self) -> usize

Returns the number of possible values (flavors) for each variable. For binary problems, this is 2.

fn problem_size(&self) -> ProblemSize

Returns metadata about the problem size.

fn energy_mode(&self) -> EnergyMode

Returns whether larger or smaller objective values are better.

fn solution_size(&self, config: &[usize]) -> SolutionSize<f64>

Evaluate the solution size for a given configuration.

fn variables(&self) -> Range<usize>

Returns the range of variable indices.

fn flavors(&self) -> Vec<usize>

Returns the possible flavors as a vector.

fn is_valid_config(&self, config: &[usize]) -> bool

Check if a configuration is valid for this problem.

fn solution_size_multiple( &self, configs: &[Vec<usize>], ) -> Vec<SolutionSize<Self::Size>>

Evaluate multiple configurations at once (batch evaluation).

impl Serialize for ILP

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.