Introduction

Integer Programming entities in Mosel

Definition: integer programming types are defined as unary constraints on previously declared decision variables of type mpvar; name the constraints if you want to be able to access/modify them.

model "intromip"
 uses "mmxprs"
 declarations
  d: mpvar
  ifmake: array(PRODS,LINES) of mpvar
  x: mpvar
 end-declarations

 d is_binary                      ! Single binary variable
 forall(p in PRODS, l in LINES)
  ifmake(p,l) is_binary           ! An array of binaries

 ACtr:= x is_integer              ! An integer variable
 x >= MINVAL                      ! Lower bound on the variable
 x <= MAXVAL                      ! Upper bound on the variable
 ! MINVAL,MAXVAL: values between -MAX_REAL and MAX_REAL
 ...
 ACtr:= x is_partint 10           ! Change type to partial integer
 ...
 ACtr:= 0                         ! Delete constraint
! Equivalently:
 ACtr:= x is_continuous           ! Change type to continuous
 ...

Solving: with Xpress Optimizer (Mosel module mmxprs) any problem containing integer programming entities is automatically solved as a MIP problem, to solve just the LP relaxation use option XPRS_LPSTOP (if following up with MIP search) or XPRS_LIN (ignore all MIP information) for maximize / minimize.

 minimize(d)                      ! Solve the MIP problem
 minimize(XPRS_LPSTOP, d)         ! Solve the LP releaxation

Accessing the solution: for obtaining solution values of decision variables and linear expressions use getsol (alternative syntax: .sol); the MIP problem status is returned by the function getparam("XPRS_MIPSTATUS")

 case getparam("XPRS_MIPSTATUS") of
  XPRS_MIP_NOT_LOADED,
    XPRS_MIP_LP_NOT_OPTIMAL: writeln("Solving not started")
  XPRS_MIP_LP_OPTIMAL:       writeln("Root LP solved")
  XPRS_MIP_UNBOUNDED:        writeln("LP unbounded")
  XPRS_MIP_NO_SOL_FOUND,
    XPRS_MIP_INFEAS:         writeln("MIP search started, no solution")
  XPRS_MIP_SOLUTION,
    XPRS_MIP_OPTIMAL:        writeln("MIP solution: ", , getobjval)
 end-case

 writeln("x: ", getsol(x))
 writeln("d: ", d.sol)

Integer Programming entities in the Xpress Python API

Definition: Integer Programming types are specified when creating decision variables; types may be changed with vartype.

import xpress as xp

MAXVAL = 50
NP = 5
NL = 6

p = xp.problem()

# A single binary variable
d = p.addVariable(vartype=xp.binary, name="d")

# A NumPy array of variables
ifmake = p.addVariables(NP, NL, vartype=xp.binary, name="ifmake")

 # An integer variable with an upper bound
x = p.addVariable(lb=0, ub=MAXVAL, vartype=xp.integer, name="x")

x.vartype = xp.partiallyinteger    # Change type to partial integer
x.threshold = 10

x.vartype = xp.continuous          # Change type to continuous

Solving: to solve a MIP problem use method optimize of xp.problem. This call is usually preceded by the definition of the objective function via setObjective that also allows you to change the sense of the optimization (the default optimization direction is minimization).

p.setObjective(d)
p.optimize()

Accessing the solution: for obtaining solution values of decision variables use getSolution; the MIP problem status is returned by p.attributes.solstatus. Import SolStatus from xpress.enums at the top of the script to access the possible solution values.

from xpress.enums import SolStatus

match p.attributes.solstatus:
    case SolStatus.FEASIBLE | SolStatus.OPTIMAL:
        print("MIP solution: ", p.attributes.objval())
    case SolStatus.INFEASIBLE:
        print("Problem is infeasible")
    case SolStatus.UNBOUNDED:
        print("LP unbounded")
    case SolStatus.NOTFOUND:
        print("Solution not found")

print(x.name,": ",p.getSolution(x))

Integer Programming entities in the Xpress C++ API

The code extracts for the object-oriented APIs of Xpress Solver shown in this document are formulated for the C++ interface. The other object-oriented APIs (Java, C#) work similarly, please refer to the Xpress Java API user guide and Xpress C# API user guide for further detail.

Definition: Integer Programming types are specified when creating decision variables; types may be changed with setType.

#include <iostream>
#include <xpress.hpp>
using namespace xpress;
using namespace xpress::objects;
using namespace std;

int main()
{
  XpressProblem prob;

  Variable d = prob.addVariable(ColumnType::Binary, "d"); // Single binary variable

  auto ifmake = prob.addVariables(NP, NL)  // 2-dim array of binary variables
    .withType(ColumnType::Binary)
    .withName("ifmake_%d_%d")    .toArray();

  // An integer variable
  Variable x = prob.addVariable(0, MAXVAL, ColumnType::Integer, "x");
  ...
  x.setType(ColumnType::PartialInteger);   // Change type to partial integer
  x.setLimit(10);                          // Set the partial integer limit value
  ...
  x.setType(ColumnType::Continuous);       // Change type to continuous
  ...

Solving: to solve a MIP problem use method optimize of XpressProblem. This call is usually preceded by the definition of the objective function via setObjective that also allows you to change the sense of the optimization (the default optimization direction is minimization). To solve just the LP relaxation use lpOptimize.

  prob.setObjective(d, ObjSense::Maximize);
  prob.optimize();

Accessing the solution: for obtaining solution values of decision variables use getSolution; the MIP problem status is returned by the attribute getMipStatus.

  auto mipStatus = prob.attributes.getMipStatus();
  switch (mipStatus) {
    case MIPStatus::NotLoaded:
    case MIPStatus::LPNotOptimal:
      cout << "Solving not started" << endl;
      break;
    case MIPStatus::LPOptimal:
      cout << "Root LP solved" << endl;
      break;
    case MIPStatus::Unbounded:
      cout << "LP unbounded" << endl;
      break;
    case MIPStatus::NoSolutionFound:
    case MIPStatus::Infeasible:
      cout << "MIP search started, no solution" << endl;
      break;
    case MIPStatus::Solution:
    case MIPStatus::Optimal:
      cout << "MIP solution: " << prob.attributes.getObjVal() << endl;
      break;
  }

  cout << x.getName() << ": " << x.getSolution() << endl;