Convert qplib to ommx

Zengor · Zengor · commit 0452b6335c3e · 2025-01-08T15:22:42.000+09:00
diff --git a/rust/ommx/src/mps/convert.rs b/rust/ommx/src/mps/convert.rs
@@ -70,7 +70,7 @@ fn convert_dvars(mps: &Mps) -> (Vec<v1::DecisionVariable>, HashMap<ColumnName, u
             let id = i as u64;
             name_id_map.insert(var_name.clone(), id);
             dvars.push(v1::DecisionVariable {
-                id: i as u64,
+                id,
                 kind,
                 bound: Some(bound),
                 name: Some(var_name.0.clone()),
diff --git a/rust/ommx/src/qplib.rs b/rust/ommx/src/qplib.rs
@@ -1,14 +1,15 @@
-use std::{io::Read, path::Path};
+use prost::Message;
+use std::path::Path;
 
+mod convert;
 mod parser;
 
-use parser::*;
+use parser::QplibFile;
 
 /// Reads and parses the file at the given path as a gzipped MPS file.
 pub fn load_file(path: impl AsRef<Path>) -> Result<crate::v1::Instance, QplibParseError> {
-    let data = Qplib::from_file(path)?;
-    // TODO
-    // convert::convert(data)
+    let data = QplibFile::from_file(path)?;
+    convert::convert(data)
 }
 
 pub fn load_file_bytes(path: impl AsRef<Path>) -> Result<Vec<u8>, QplibParseError> {
diff --git a/rust/ommx/src/qplib/convert.rs b/rust/ommx/src/qplib/convert.rs
@@ -0,0 +1,231 @@
+use itertools::izip;
+use num::Zero;
+
+use super::{
+    parser::{ObjSense, QplibFile, VarType},
+    QplibParseError,
+};
+use crate::v1;
+use std::collections::HashMap;
+
+pub fn convert(mut qplib: QplibFile) -> Result<v1::Instance, QplibParseError> {
+    qplib.apply_infinity_threshold();
+    let description = convert_description(&qplib);
+    let decision_variables = convert_dvars(&qplib);
+    let objective = convert_objective(&qplib);
+    let constraints = convert_constraints(&qplib);
+    Ok(v1::Instance {
+        description: Some(description),
+        decision_variables,
+        objective: Some(objective),
+        constraints,
+        sense: convert_sense(qplib.sense),
+        ..Default::default()
+    })
+}
+
+fn convert_description(qplib: &QplibFile) -> v1::instance::Description {
+    // currently only gets the name
+    let name = if qplib.name.is_empty() {
+        None
+    } else {
+        Some(qplib.name.clone())
+    };
+    let description = qplib.problem_type.to_string();
+    v1::instance::Description {
+        name,
+        description: Some(description),
+        ..Default::default()
+    }
+}
+
+fn convert_dvars(qplib: &QplibFile) -> Vec<v1::DecisionVariable> {
+    let QplibFile {
+        var_types,
+        lower_bounds,
+        upper_bounds,
+        var_names,
+        ..
+    } = qplib;
+    let mut dvars = Vec::with_capacity(var_types.len());
+    for (i, (t, &lower, &upper)) in izip!(var_types, lower_bounds, upper_bounds).enumerate() {
+        let id = i as u64;
+        let name = var_names.get(&i).cloned();
+        let kind = match t {
+            VarType::Continuous => v1::decision_variable::Kind::Continuous as i32,
+            VarType::Integer => v1::decision_variable::Kind::Integer as i32,
+            VarType::Binary => v1::decision_variable::Kind::Binary as i32,
+        };
+        let bound = v1::Bound { lower, upper };
+        dvars.push(v1::DecisionVariable {
+            id,
+            kind,
+            bound: Some(bound),
+            name,
+            ..Default::default()
+        })
+    }
+    dvars
+}
+
+fn convert_objective(qplib: &QplibFile) -> v1::Function {
+    let quadratic = to_quadratic(&qplib.q0_non_zeroes);
+    let linear = if qplib.default_b0 == 0.0 {
+        to_linear(&qplib.b0_non_defaults)
+    } else {
+        // non-zero default value: transform into dense vec using the default value and update
+        // with non-defaults
+        let mut terms: Vec<_> = (0..qplib.num_vars as u64)
+            .map(|i| v1::linear::Term {
+                id: i,
+                coefficient: qplib.default_b0,
+            })
+            .collect();
+        for (&i, &coeff) in qplib.b0_non_defaults.iter() {
+            terms[i].coefficient = coeff;
+        }
+        // remove any terms which may have been explicitly set to 0.0
+        terms.retain(|t| t.coefficient != 0.0);
+        v1::Linear {
+            terms,
+            constant: 0.0, // constant will be added later
+        }
+    };
+    // simplify function to linear/constant if appropriate terms not
+    // present
+    wrap_function(quadratic, linear, qplib.obj_constant)
+}
+
+fn convert_constraints(qplib: &QplibFile) -> Vec<v1::Constraint> {
+    let QplibFile {
+        num_constraints,
+        qs_non_zeroes,
+        bs_non_zeroes,
+        constr_lower_cs,
+        constr_upper_cs,
+        constr_names,
+        ..
+    } = qplib;
+    // technically num_constraints is only a lower bound on the capacity
+    // required as one Qplib constraint might equal 2 ommx constraints.
+    let mut constraints = Vec::with_capacity(*num_constraints);
+    for (i, (qs, bs, &lower_c, &upper_c)) in izip!(
+        qs_non_zeroes,
+        bs_non_zeroes,
+        constr_lower_cs,
+        constr_upper_cs
+    )
+    .enumerate()
+    {
+        let mut quadratic = to_quadratic(qs);
+        let mut linear = to_linear(bs);
+        let name = constr_names
+            .get(&i)
+            .cloned()
+            .unwrap_or_else(|| format!("Qplib_constr_{i}"));
+        // QPLIB constraints are two-sided, as in, `c_l <= expr <= c_u`.
+        // To represent a one-sided constraint, c_l or c_u are set to the infinity
+        // threshold. This means a single constraint translates to potentially 2
+        // OMMX constraints.
+        //
+        // Currently we don't perform any checks for equality constraints
+        // (represented in QPLIB by setting `c_l` and `c_u` to the same value)
+        //
+        // We don't create a `v1::Constraint` for sides where `c` is infinity.
+        //
+        // ID translation scheme (subject to potential change):
+        //
+        // - The `<= c_u` side is given the same ID as the constraint in the
+        // QPLIB file.
+        //
+        // - The `>= c_l` side is given a new ID, which is `num_constraints +
+        // id`. Hence in a QPLIB file with 10 constraints, the `c_l` side of
+        // constraint 0 is 10; for constraint 1 it's 11, and so on.
+        //
+        // This scheme means the resulting OMMX instance will have
+        // non-contiguous constraint IDs if some constraints have no valid `<=
+        // c_u` side.
+        if upper_c != f64::INFINITY {
+            // move upper_c to the LHS multiplied by -1.
+            let func = wrap_function(quadratic.clone(), linear.clone(), -upper_c);
+            constraints.push(v1::Constraint {
+                id: i as u64,
+                equality: v1::Equality::LessThanOrEqualToZero as i32,
+                function: Some(func),
+                name: Some(format!("{name} [c_u]")),
+                ..Default::default()
+            });
+        }
+
+        if lower_c != f64::NEG_INFINITY {
+            // multiply ALL coefficients by -1, move constant to LHS
+            quadratic.values.iter_mut().for_each(|v| *v *= -1.);
+            linear.terms.iter_mut().for_each(|t| t.coefficient *= -1.);
+            let func = wrap_function(quadratic, linear, lower_c);
+            constraints.push(v1::Constraint {
+                id: (num_constraints + i) as u64,
+                equality: v1::Equality::LessThanOrEqualToZero as i32,
+                function: Some(func),
+                name: Some(format!("{name} [c_l]")),
+                ..Default::default()
+            });
+        }
+    }
+    constraints
+}
+
+fn to_quadratic(coeff_map: &HashMap<(usize, usize), f64>) -> v1::Quadratic {
+    let mut rows = Vec::with_capacity(coeff_map.len());
+    let mut columns = Vec::with_capacity(coeff_map.len());
+    let mut values = Vec::with_capacity(coeff_map.len());
+    for ((row, col), val) in coeff_map.iter() {
+        rows.push(*row as u64);
+        columns.push(*col as u64);
+        values.push(*val);
+    }
+    v1::Quadratic {
+        rows,
+        columns,
+        values,
+        linear: None,
+    }
+}
+
+fn to_linear(coeffs: &HashMap<usize, f64>) -> v1::Linear {
+    let terms: Vec<_> = coeffs
+        .iter()
+        .map(|(id, coeff)| v1::linear::Term {
+            id: *id as u64,
+            coefficient: *coeff,
+        })
+        .collect();
+    v1::Linear {
+        terms,
+        constant: 0.0,
+    }
+}
+
+fn wrap_function(mut quad: v1::Quadratic, mut linear: v1::Linear, constant: f64) -> v1::Function {
+    let func = if quad.is_zero() {
+        if linear.terms.is_empty() {
+            v1::function::Function::Constant(constant)
+        } else {
+            linear.constant = constant;
+            v1::function::Function::Linear(linear)
+        }
+    } else {
+        linear.constant = constant;
+        quad.linear = Some(linear);
+        v1::function::Function::Quadratic(quad)
+    };
+    v1::Function {
+        function: Some(func),
+    }
+}
+
+fn convert_sense(sense: ObjSense) -> i32 {
+    match sense {
+        ObjSense::Minimize => v1::instance::Sense::Minimize as i32,
+        ObjSense::Maximize => v1::instance::Sense::Maximize as i32,
+    }
+}
diff --git a/rust/ommx/src/qplib/parser.rs b/rust/ommx/src/qplib/parser.rs
@@ -1,6 +1,7 @@
-use crate::error::QplibParseError;
+use super::QplibParseError;
 use std::collections::HashMap;
 use std::{
+    fmt::Display,
     fs,
     io::{self, BufRead, Read},
     path::Path,
@@ -205,6 +206,12 @@ impl QplibFile {
 #[derive(Default, Debug)]
 pub struct ProblemType(ProbObjKind, ProbVarKind, ProbConstrKind);
 
+impl Display for ProblemType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}{}{}", self.0, self.1, self.2)
+    }
+}
+
 #[derive(Clone, Copy, Default, Debug, PartialEq)]
 pub enum ProbObjKind {
     Linear,
@@ -214,6 +221,18 @@ pub enum ProbObjKind {
     Quadratic, // generic case
 }
 
+impl Display for ProbObjKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let c = match self {
+            ProbObjKind::Linear => 'L',
+            ProbObjKind::DiagonalC => 'D',
+            ProbObjKind::ConcaveOrConvex => 'C',
+            ProbObjKind::Quadratic => 'Q',
+        };
+        write!(f, "{c}")
+    }
+}
+
 #[derive(Clone, Copy, Default, Debug, PartialEq)]
 pub enum ProbVarKind {
     Continuous,
@@ -224,6 +243,19 @@ pub enum ProbVarKind {
     General,
 }
 
+impl Display for ProbVarKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let c = match self {
+            ProbVarKind::Continuous => 'C',
+            ProbVarKind::Binary => 'B',
+            ProbVarKind::Mixed => 'M',
+            ProbVarKind::Integer => 'I',
+            ProbVarKind::General => 'G',
+        };
+        write!(f, "{c}")
+    }
+}
+
 #[derive(Clone, Copy, Default, Debug, PartialEq)]
 pub enum ProbConstrKind {
     None,
@@ -235,6 +267,20 @@ pub enum ProbConstrKind {
     Quadratic,
 }
 
+impl Display for ProbConstrKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let c = match self {
+            ProbConstrKind::None => 'N',
+            ProbConstrKind::Box => 'B',
+            ProbConstrKind::Linear => 'L',
+            ProbConstrKind::DiagonalConvex => 'D',
+            ProbConstrKind::Convex => 'C',
+            ProbConstrKind::Quadratic => 'Q',
+        };
+        write!(f, "{c}")
+    }
+}
+
 impl FromStr for ProblemType {
     type Err = QplibParseError;
 
@@ -346,11 +392,13 @@ fn integer_to_binary(
 /// the form `c_l <= expr <= c_u`. When a problem has to define a constraint
 /// that is only `expr <= c_u`, for example, they set `c_l` to infinity.
 ///
-/// Ommx, however, only allows constraints to be `<= 0` or `>= 0`. The first
-/// step in handlign this is splitting the constraint into into `expr <= c_u`
-/// and `expr >= c_l`. Mathematically, we don't need special handling for this
-/// and can just split _all_ constraints into both kinds. But we choose to check
+/// Ommx, however, only allows constraints to be `<= 0` or `= 0`. The first step
+/// in handlign this is splitting the constraint into into `expr <= c_u` and
+/// `expr >= c_l`. Mathematically, we don't need special handling for this and
+/// can just split _all_ constraints into both kinds. But we choose to check
 /// this so the number of trivial constraints passed on is greatly reduced.
+/// Later handling will be responsible for transforming constraints into a `<=
+/// 0` form.
 ///
 /// The intent here to reduce the size of the instance by not adding the full
 /// `c_l` and `c_u` lists, removing all infinties. For problems with lots of
