Linear Programming in IronPython QuickStart Sample

Illustrates solving linear programming (LP) problems using classes in the Numerics.NET.Optimization.LinearProgramming namespace in IronPython.

This sample is also available in: C#, Visual Basic, F#.

Overview

This QuickStart sample demonstrates how to solve linear programming problems using Numerics.NET’s optimization capabilities. Linear programming is a method for achieving the best outcome in a mathematical model whose requirements are represented by linear relationships.

The sample illustrates three different approaches to creating and solving linear programs:

  1. Matrix-based approach - Shows how to construct a linear program by specifying the cost vector, constraint coefficients matrix, and right-hand side vector directly. This is useful when working with problems that are naturally expressed in matrix form.

  2. Incremental construction - Demonstrates building a linear program step by step by adding variables and constraints individually. This approach provides more clarity and is often more maintainable for smaller problems.

  3. MPS file input - Shows how to read a linear program from an MPS format file, which is an industry standard format for representing linear and integer programming problems.

For each approach, the sample shows how to:

  • Set up the linear program
  • Solve it using the Revised Simplex algorithm
  • Retrieve both the primal and dual solutions
  • Access the optimal objective value

The sample includes proper error handling and demonstrates best practices for working with the LinearProgram class.

The code

import numerics

# The linear programming classes reside in a namespace with
# other optimization-related classes.
from Extreme.Mathematics.Optimization import *
# Vectors and matrices are in the Extreme.Mathematics.LinearAlgebra
# namespace
from Extreme.Mathematics import *

# Illustrates solving linear programming problems
# using the classes in the Extreme.Mathematics.Optimization
# namespace of Extreme Numerics.NET.

# This QuickStart Sample illustrates the three ways to create a Linear Program.

# The first is in terms of matrices. The coefficients
# are supplied as a matrix. The cost vector, right-hand side
# and constraints on the variables are supplied as a vector.

# The cost vector:
c = Vector([ -1.0, -3.0, 0.0, 0.0, 0.0, 0.0 ])
# The coefficients of the constraints:
A = Matrix([[1,1,1,0,0,0], [1,1,0,-1,0,0], [1,0,0,0,1,0], [0,1,0,0,0,1 ]])
# The right-hand sides of the constraints:
b = Vector([ 1.5, 0.5, 1.0, 1.0])

# We're now ready to call the constructor.
# The last parameter specifies the number of equality
# constraints.
lp1 = LinearProgram(c, A, b, 4)

# Now we can call the Solve method to run the Revised
# Simplex algorithm:
x = lp1.Solve()
# The GetDualSolution method returns the dual solution:
y = lp1.GetDualSolution()
print "Primal: {0:.1f}".format(x)
print "Dual:   {0:.1f}".format(y)
# The optimal value is returned by the Extremum property:
print "Optimal value:   {0:.1f}".format(lp1.OptimalValue)

# The second way to create a Linear Program is by constructing
# it by hand. We start with an 'empty' linear program.
lp2 = LinearProgram()

# Next, we add two variables: we specify the name, the cost, # and optionally the lower and upper bound.
lp2.AddVariable("X1", -1.0, 0, 1)
lp2.AddVariable("X2", -3.0, 0, 1)

# Next, we add constraints. Constraints also have a name.
# We also specify the coefficients of the variables, # the lower bound and the upper bound.
lp2.AddLinearConstraint("C1", Vector.Create(1.0, 1.0), 0.5, 1.5)
# If a constraint is a simple equality or inequality constraint, # you can supply a LinearProgramConstraintType value and the
# right-hand side of the constraint.

# We can now solve the linear program:
x = lp2.Solve()
y = lp2.GetDualSolution()
print "Primal: {0:.1f}".format(x)
print "Dual:   {0:.1f}".format(y)
print "Optimal value:   {0:.1f}".format(lp2.OptimalValue)

# Finally, we can create a linear program from an MPS file.
# The MPS format is a standard format.
lp3 = MpsReader.Read(r"..\data\sample.mps")
# We can go straight to solving the linear program:
x = lp3.Solve()
y = lp3.GetDualSolution()
print "Primal: {0:.1f}".format(x)
print "Dual:   {0:.1f}".format(y)
print "Optimal value:   {0:.1f}".format(lp3.OptimalValue)