lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/examples/call_highs_from_python.py

@@ -0,0 +1,448 @@
+# The paths to MPS file instances assumes that this is run in the
+# root directory of HiGHS
+
+import numpy as np
+import highspy
+
+hscb = highspy.cb 
+
+# Constants for iteration limits or objective targets, adjust as required
+SIMPLEX_ITERATION_LIMIT = 100
+IPM_ITERATION_LIMIT = 100
+EGOUT_OBJECTIVE_TARGET = 610.0
+
+h = highspy.Highs()
+
+# h.setOptionValue("log_to_console", True)
+
+inf = highspy.kHighsInf
+alt_inf = h.getInfinity()
+print('highspy.kHighsInf = ', inf,
+      'h.getInfinity() = ', alt_inf)
+
+# ~~~
+# Read in and solve avgas
+h.readModel("check/instances/avgas.mps")
+
+# h.writeModel("ml.mps")
+
+h.run()
+lp = h.getLp()
+num_nz = h.getNumNz()
+print("LP has ", lp.num_col_,
+      " columns", lp.num_row_,
+      " rows and ", num_nz, " nonzeros.")
+
+# ~~~
+# Clear so that incumbent model is empty
+h.clear()
+
+# Now define the blending model as a HighsLp instance
+lp = highspy.HighsLp()
+lp.num_col_ = 2
+lp.num_row_ = 2
+lp.sense_ = highspy.ObjSense.kMaximize
+lp.col_cost_ = np.array([8, 10], dtype=np.double)
+lp.col_lower_ = np.array([0, 0], dtype=np.double)
+lp.col_upper_ = np.array([inf, inf], dtype=np.double)
+lp.row_lower_ = np.array([-inf, -inf], dtype=np.double)
+lp.row_upper_ = np.array([120, 210], dtype=np.double)
+lp.a_matrix_.start_ = np.array([0, 2, 4])
+lp.a_matrix_.index_ = np.array([0, 1, 0, 1])
+lp.a_matrix_.value_ = np.array([0.3, 0.7, 0.5, 0.5], dtype=np.double)
+h.passModel(lp)
+
+# Solve
+h.run()
+
+# Print solution
+solution = h.getSolution()
+basis = h.getBasis()
+info = h.getInfo()
+# basis.col_status and basis.row_status are already lists, but
+# accessing values in solution.col_value and solution.row_value
+# directly is very inefficient, so convert them to lists
+col_status = basis.col_status
+row_status = basis.row_status
+col_value = list(solution.col_value)
+row_value = list(solution.row_value)
+model_status = h.getModelStatus()
+print("Model status = ", h.modelStatusToString(model_status))
+print("Optimal objective = ", info.objective_function_value)
+print("Iteration count = ", info.simplex_iteration_count)
+print(
+    "Primal solution status = ", h.solutionStatusToString(
+        info.primal_solution_status)
+)
+print("Dual solution status = ",
+      h.solutionStatusToString(info.dual_solution_status))
+print("Basis validity = ", h.basisValidityToString(info.basis_validity))
+num_var = h.getNumCol()
+num_row = h.getNumRow()
+print("Variables")
+for icol in range(num_var):
+    print(icol, col_value[icol],
+          h.basisStatusToString(col_status[icol]))
+print("Constraints")
+for irow in range(num_row):
+    print(irow, row_value[irow],
+          h.basisStatusToString(row_status[irow]))
+
+# ~~~
+# Clear so that incumbent model is empty
+h.clear()
+
+# Now define the test-semi-definite0 model (from TestQpSolver.cpp) 
+# as a HighsModel instance
+model = highspy.HighsModel()
+model.lp_.model_name_ = "semi-definite"
+model.lp_.num_col_ = 3
+model.lp_.num_row_ = 1
+model.lp_.col_cost_ = np.array([1.0, 1.0, 2.0], dtype=np.double)
+model.lp_.col_lower_ = np.array([0, 0, 0], dtype=np.double)
+model.lp_.col_upper_ = np.array([inf, inf, inf], dtype=np.double)
+model.lp_.row_lower_ = np.array([2], dtype=np.double)
+model.lp_.row_upper_ = np.array([inf], dtype=np.double)
+model.lp_.a_matrix_.format_ = highspy.MatrixFormat.kColwise
+model.lp_.a_matrix_.start_ = np.array([0, 1, 2, 3])
+model.lp_.a_matrix_.index_ = np.array([0, 0, 0])
+model.lp_.a_matrix_.value_ = np.array([1.0, 1.0, 1.0], dtype=np.double)
+model.hessian_.dim_ = model.lp_.num_col_
+model.hessian_.start_ = np.array([0, 2, 2, 3])
+model.hessian_.index_ = np.array([0, 2, 2])
+model.hessian_.value_ = np.array([2.0, -1.0, 1.0], dtype=np.double)
+
+print("test-semi-definite0 as HighsModel")
+h.passModel(model)
+h.run()
+
+# ~~~
+# Clear so that incumbent model is empty
+h.clear()
+num_col = 3
+num_row = 1
+sense = highspy.ObjSense.kMinimize
+offset = 0
+col_cost = np.array([1.0, 1.0, 2.0], dtype=np.double)
+col_lower = np.array([0, 0, 0], dtype=np.double)
+col_upper = np.array([inf, inf, inf], dtype=np.double)
+row_lower = np.array([2], dtype=np.double)
+row_upper = np.array([inf], dtype=np.double)
+a_matrix_format = highspy.MatrixFormat.kColwise
+a_matrix_start = np.array([0, 1, 2, 3])
+a_matrix_index = np.array([0, 0, 0])
+a_matrix_value = np.array([1.0, 1.0, 1.0], dtype=np.double)
+a_matrix_num_nz = a_matrix_start[num_col]
+hessian_format = highspy.HessianFormat.kTriangular
+hessian_start = np.array([0, 2, 2, 3])
+hessian_index = np.array([0, 2, 2])
+hessian_value = np.array([2.0, -1.0, 1.0], dtype=np.double)
+hessian_num_nz = hessian_start[num_col]
+integrality = np.array([0, 0, 0])
+
+print("test-semi-definite0 as pointers")
+h.passModel(
+    num_col,
+    num_row,
+    a_matrix_num_nz,
+    hessian_num_nz,
+    a_matrix_format,
+    hessian_format,
+    sense,
+    offset,
+    col_cost,
+    col_lower,
+    col_upper,
+    row_lower,
+    row_upper,
+    a_matrix_start,
+    a_matrix_index,
+    a_matrix_value,
+    hessian_start,
+    hessian_index,
+    hessian_value,
+    integrality,
+)
+h.run()
+h.writeSolution("", 1)
+
+# ~~~
+# Clear so that incumbent model is empty
+h.clear()
+print("25fv47 as HighsModel")
+
+h.readModel("check/instances/25fv47.mps")
+
+h.presolve()
+presolved_lp = h.getPresolvedLp()
+
+# Create a HiGHS instance to solve the presolved LP
+print('\nCreate Highs instance to solve presolved LP')
+h1 = highspy.Highs()
+h1.passModel(presolved_lp)
+
+# Get and set options
+options = h1.getOptions()
+options.presolve = "off"
+options.solver = "ipm"
+
+h1.passOptions(options)
+
+# can be used to check option values
+# h1.writeOptions("")
+
+h1.run()
+solution = h1.getSolution()
+basis = h1.getBasis()
+
+print("Crossover, then postsolve using solution and basis from another instance")
+
+h.postsolve(solution, basis)
+
+# Get solution
+info = h.getInfo()
+model_status = h.getModelStatus()
+print("Model status = ", h.modelStatusToString(model_status))
+print("Optimal objective = ", info.objective_function_value)
+print("Iteration count = ", info.simplex_iteration_count)
+
+run_time = h.getRunTime()
+print("Total HiGHS run time is ", run_time)
+
+# Get an optimal basis
+
+# Clear so that incumbent model is empty
+h.clear()
+print("25fv47 as HighsModel")
+
+h.readModel("check/instances/25fv47.mps")
+
+h.run()
+simplex_iteration_count = h.getInfo().simplex_iteration_count
+print("From initial basis, simplex iteration count =", simplex_iteration_count)
+basis = h.getBasis()
+h.clearSolver()
+
+h.setBasis(basis)
+h.run()
+simplex_iteration_count = h.getInfo().simplex_iteration_count
+print("From optimal basis, simplex iteration count =", simplex_iteration_count)
+status = h.setBasis()
+h.run()
+simplex_iteration_count = h.getInfo().simplex_iteration_count
+print("From logical basis, simplex iteration count =", simplex_iteration_count)
+
+
+# Define a callback
+
+def user_callback(
+    callback_type,
+    message,
+    data_out,
+    data_in,
+    user_callback_data
+):
+    dev_run = True
+    #dev_run = False
+
+    # Callback for MIP Improving Solution
+    if callback_type == hscb.HighsCallbackType.kCallbackMipImprovingSolution:
+        # Assuming it is a list or array
+        assert user_callback_data is not None, "User callback data is None!"
+
+        if dev_run:
+            print(f"userCallback(type {callback_type}; "
+                  f"data {user_callback_data:.4g}): {message} "
+                  f"with objective {data_out.objective_function_value:.4g}")
+            print(f"and solution[0] = {data_out.mip_solution[0]}")
+            print(f"and solution[1] = {data_out.mip_solution[1]}")
+
+        # Check and update the objective function value
+        assert (
+            user_callback_data >= data_out.objective_function_value
+        ), "Objective function value is invalid!"
+        user_callback_data = data_out.objective_function_value
+
+    else:
+        # Various other callback types
+        if callback_type == hscb.HighsCallbackType.kCallbackLogging:
+            if dev_run:
+                print(f"userInterruptCallback(type {callback_type}): {message}")
+
+        elif callback_type == hscb.HighsCallbackType.kCallbackSimplexInterrupt:
+            if dev_run:
+                print(f"userInterruptCallback(type {callback_type}): {message}")
+                print("with iteration count = ", 
+                      data_out.simplex_iteration_count)
+
+            data_in.user_interrupt = (
+                data_out.simplex_iteration_count > SIMPLEX_ITERATION_LIMIT
+            )
+
+        elif callback_type == hscb.HighsCallbackType.kCallbackIpmInterrupt:
+            if dev_run:
+                print(f"userInterruptCallback(type {callback_type}): {message}")
+                print(f"with iteration count = {data_out.ipm_iteration_count}")
+
+            data_in.user_interrupt = (
+                data_out.ipm_iteration_count > IPM_ITERATION_LIMIT
+            )
+
+        elif callback_type == hscb.HighsCallbackType.kCallbackMipInterrupt:
+            if dev_run:
+                print(f"userInterruptCallback(type {callback_type}; "
+                  f"data {user_callback_data:.4g}): {message} "
+                  f"with objective {data_out.objective_function_value:.4g}")
+                print(f"Dual bound = {data_out.mip_dual_bound:.4g}")
+                print(f"Primal bound = {data_out.mip_primal_bound:.4g}")
+                print(f"Gap = {data_out.mip_gap:.4g}")
+
+            data_in.user_interrupt = (
+                data_out.objective_function_value < user_callback_data
+            )
+
+
+# Define model
+h.addVar(-inf, inf)
+h.addVar(-inf, inf)
+h.changeColsCost(2, np.array([0, 1]), np.array([0, 1], dtype=np.double))
+num_cons = 2
+lower = np.array([2, 0], dtype=np.double)
+upper = np.array([inf, inf], dtype=np.double)
+num_new_nz = 4
+starts = np.array([0, 2])
+indices = np.array([0, 1, 0, 1])
+values = np.array([-1, 1, 1, 1], dtype=np.double)
+h.addRows(num_cons, lower, upper, num_new_nz, starts, indices, values)
+
+
+# Set callback and run
+h.setCallback(user_callback, None)
+h.startCallback(hscb.HighsCallbackType.kCallbackLogging)
+
+h.run()
+h.stopCallback(hscb.HighsCallbackType.kCallbackLogging)
+
+# Get solution
+num_var = h.getNumCol()
+solution = h.getSolution()
+basis = h.getBasis()
+info = h.getInfo()
+# basis.col_status is already a list, but accessing values in
+# solution.col_value directly is very inefficient, so convert it to a
+# list
+col_status = basis.col_status
+col_value = list(solution.col_value)
+model_status = h.getModelStatus()
+print("Model status = ", h.modelStatusToString(model_status))
+print("Optimal objective = ", info.objective_function_value)
+print("Iteration count = ", info.simplex_iteration_count)
+print(
+    "Primal solution status = ", h.solutionStatusToString(
+        info.primal_solution_status)
+)
+print("Dual solution status = ",
+      h.solutionStatusToString(info.dual_solution_status))
+print("Basis validity = ", h.basisValidityToString(info.basis_validity))
+print("Variables:")
+for icol in range(0, 5):
+    print(icol, col_value[icol],
+          h.basisStatusToString(col_status[icol]))
+print("...")
+for icol in range(num_var-2, num_var):
+    print(icol, col_value[icol],
+          h.basisStatusToString(col_status[icol]))
+
+# ~~~
+# Clear so that incumbent model is empty
+h.clear()
+
+# Test MIP callbacks
+print("\negout as HighsModel")
+
+h.setOptionValue("output_flag", False);
+h.setOptionValue("presolve", "off");
+
+h.readModel("check/instances/egout.mps")
+
+for iCase in range(0, 2):
+    if iCase == 0:
+        user_callback_data = EGOUT_OBJECTIVE_TARGET;
+        h.setCallback(user_callback, user_callback_data)
+        h.startCallback(hscb.HighsCallbackType.kCallbackMipInterrupt)
+        required_model_status = highspy.HighsModelStatus.kInterrupt
+    else:
+        user_callback_data = 1e30;
+        h.setCallback(user_callback, user_callback_data)
+        h.startCallback(hscb.HighsCallbackType.kCallbackMipImprovingSolution)
+        required_model_status = highspy.HighsModelStatus.kOptimal
+
+    h.run()
+
+    assert (h.getModelStatus() == required_model_status)
+
+    print(f"user_callback_data = {user_callback_data}: Success!")
+    h.clearSolver()
+
+# ~~~
+# Clear so that incumbent model is empty
+h.clear()
+
+# Build an infeasible LP problem
+# Problem: minimize x + y
+# Subject to: x + y <= 0.5 and x + y >= 2.0 (contradictory constraints)
+# Bounds: 0 <= x <= 1, 0 <= y <= 1
+
+lp = highspy.HighsLp()
+lp.num_col_ = 2
+lp.num_row_ = 2
+
+# Objective: minimize x + y
+lp.col_cost_ = [1.0, 1.0]
+
+# Variable bounds: 0 <= x <= 1, 0 <= y <= 1
+lp.col_lower_ = [0.0, 0.0]
+lp.col_upper_ = [1.0, 1.0]
+
+# Constraints:
+# Row 0: x + y <= 0.5
+# Row 1: -x - y <= -2.0  (equivalent to x + y >= 2.0)
+lp.row_lower_ = [-np.inf, -np.inf]
+lp.row_upper_ = [0.5, -2.0]
+
+# Constraint matrix (CSC format)
+lp.a_matrix_.start_ = [0, 2, 4]
+lp.a_matrix_.index_ = [0, 1, 0, 1]  # Row indices
+lp.a_matrix_.value_ = [1.0, 1.0, -1.0, -1.0]  # Coefficients
+
+# Pass model to HiGHS
+h.passModel(lp)
+
+# Solve the problem
+h.run()
+
+model_status = h.getModelStatus()
+
+# Change the IIS strategy from the default (use the "light" strategy
+# of testing for incompatible bounds and bounds on row activities that
+# are incomparible with row bounds) to an attempt to find an IIS -
+# although the "light" strategy is sufficient for this LP
+
+h.setOptionValue("iis_strategy", highspy.IisStrategy.kIisStrategyIrreducible)
+
+[status, iis] = h.getIis()
+
+iis_num_col = len(iis.col_index_)
+for iX in range(iis_num_col) :
+    print("IIS col ", iX, " is ", iis.col_index_[iX], " with bound status ", iis.col_bound_[iX])
+
+iis_num_row = len(iis.row_index_)
+for iX in range(iis_num_row) :
+    print("IIS row ", iX, " is ", iis.row_index_[iX], " with bound status ", iis.row_bound_[iX])
+
+# Status -1 => Not in conflict; 0 => Maybe in conflict; 1 => in conflict
+for iX in range(lp.num_col_) :
+    print("Col ", iX, " has IIS status ", iis.col_status_[iX])
+
+for iX in range(lp.num_row_) :
+    print("Row ", iX, " has IIS status ", iis.row_status_[iX])

data/ext/lpsolver-highs/examples/call_highs_from_python_highspy.py

@@ -0,0 +1,71 @@
+
+import highspy
+import numpy as np
+
+# Highs h
+h = highspy.Highs()
+
+# Set up problem
+inf = highspy.kHighsInf
+h.addVars(2, np.array([-inf, -inf]), np.array([inf, inf]))
+h.changeColsCost(2, np.array([0, 1]), np.array([0, 1], dtype=np.double));
+num_cons = 2
+lower = np.array([2, 0], dtype=np.double)
+upper = np.array([inf, inf], dtype=np.double)
+num_new_nz = 4
+starts = np.array([0, 2])
+indices = np.array([0, 1, 0, 1])
+values = np.array([-1, 1, 1, 1], dtype=np.double)
+h.addRows(num_cons, lower, upper, num_new_nz, starts, indices, values)
+
+# Access LP
+lp = h.getLp()
+num_nz = h.getNumNz()
+print('LP has ', lp.num_col_, ' columns',
+      lp.num_row_, ' rows and ', num_nz, ' nonzeros')
+
+print('Solving...')
+# Disable output from HiGHS for very small LP
+h.setOptionValue("log_to_console", False)
+
+# Solve problem
+h.run()
+
+print('Problem solved.')
+print()
+
+# Print solution information
+solution = h.getSolution()
+basis = h.getBasis()
+info = h.getInfo()
+model_status = h.getModelStatus()
+
+print('Model status = ', h.modelStatusToString(model_status))
+print('Optimal objective = ', info.objective_function_value)
+print('Iteration count = ', info.simplex_iteration_count)
+print('Primal solution status = ',
+      h.solutionStatusToString(info.primal_solution_status))
+print('Dual solution status = ',
+      h.solutionStatusToString(info.dual_solution_status))
+print('Basis validity = ', h.basisValidityToString(info.basis_validity))
+
+# basis.col_status is already a list, but accessing values in
+# solution.col_value directly is very inefficient, so convert it to a
+# list
+col_status = basis.col_status
+row_status = basis.row_status
+col_value = list(solution.col_value)
+row_value = list(solution.row_value)
+
+num_var = h.getNumCol()
+num_row = h.getNumRow()
+print("Variables")
+for icol in range(num_var):
+    print(icol, col_value[icol],
+          h.basisStatusToString(col_status[icol]))
+print("Constraints")
+for irow in range(num_row):
+    print(irow, row_value[irow],
+          h.basisStatusToString(row_status[irow]))
+
+h.clear()

data/ext/lpsolver-highs/examples/call_highs_from_python_mps.py

@@ -0,0 +1,59 @@
+
+# The path to the MPS file instance assumes that this is run 
+# from the root directory.
+
+import highspy
+import numpy as np
+
+# Highs h
+h = highspy.Highs()
+
+# Solve from mps file
+# Initialize an instance of Highs
+# h = highspy.Highs()
+# Here we are re-using the one from above.
+h.readModel('check/instances/avgas.mps')
+
+# Print
+lp = h.getLp()
+num_nz = h.getNumNz()
+print('LP has ', lp.num_col_, ' columns',
+      lp.num_row_, ' rows and ', num_nz, ' nonzeros')
+
+# Solve the problem
+h.run()
+
+# Print solution information
+solution = h.getSolution()
+basis = h.getBasis()
+info = h.getInfo()
+model_status = h.getModelStatus()
+print('Model status = ', h.modelStatusToString(model_status))
+print()
+print('Optimal objective = ', info.objective_function_value)
+print('Iteration count = ', info.simplex_iteration_count)
+print('Primal solution status = ',
+      h.solutionStatusToString(info.primal_solution_status))
+print('Dual solution status = ',
+      h.solutionStatusToString(info.dual_solution_status))
+print('Basis validity = ', h.basisValidityToString(info.basis_validity))
+
+# basis.col_status is already a list, but accessing values in
+# solution.col_value directly is very inefficient, so convert it to a
+# list
+col_status = basis.col_status
+row_status = basis.row_status
+col_value = list(solution.col_value)
+row_value = list(solution.row_value)
+
+num_var = h.getNumCol()
+num_row = h.getNumRow()
+print("Variables")
+for icol in range(num_var):
+    print(icol, col_value[icol],
+          h.basisStatusToString(col_status[icol]))
+print("Constraints")
+for irow in range(num_row):
+    print(irow, row_value[irow],
+          h.basisStatusToString(row_status[irow]))
+

data/ext/lpsolver-highs/examples/callback_gap.py

@@ -0,0 +1,71 @@
+# An example of solving the Generalized Assignment Problem (GAP) using highspy
+# Also demonstrates how to use callbacks to print cuts as they are found
+from highspy import Highs
+import numpy as np
+
+#
+# GAP instances can be taken from:
+# http://people.brunel.ac.uk/~mastjjb/jeb/orlib/gapinfo.html
+#
+# Expected format:
+# - number machines
+# _ number jobs
+# - cost of each job on each machine
+# - size of each job on each machine
+# - capacity of each machine
+
+input_data = ''' 5 15
+17 21 22 18 24 15 20 18 19 18 16 22 24 24 16
+23 16 21 16 17 16 19 25 18 21 17 15 25 17 24
+16 20 16 25 24 16 17 19 19 18 20 16 17 21 24
+19 19 22 22 20 16 19 17 21 19 25 23 25 25 25
+18 19 15 15 21 25 16 16 23 15 22 17 19 22 24
+8 15 14 23 8 16 8 25 9 17 25 15 10 8 24
+15 7 23 22 11 11 12 10 17 16 7 16 10 18 22
+21 20 6 22 24 10 24 9 21 14 11 14 11 19 16
+20 11 8 14 9 5 6 19 19 7 6 6 13 9 18
+8 13 13 13 10 20 25 16 16 17 10 10 5 12 23
+36 34 38 27 33
+'''.split()
+
+# read from file
+# with open(r"filename", 'r') as input_file:
+#     input_data = input_file.read().split()
+
+# parse input
+M = int(input_data[0])
+J = int(input_data[1])
+idx = np.cumsum([2, M * J, M * J, M])
+cost = np.array(input_data[idx[0]:idx[1]], dtype=np.float64).reshape((M, J))
+size = np.array(input_data[idx[1]:idx[2]], dtype=np.float64).reshape((M, J))
+capacity = np.array(input_data[idx[2]:idx[3]], dtype=np.float64)
+
+# build model
+model = Highs()
+
+X = model.addBinaries(M, J)
+
+# assign each job to exactly one machine
+model.addConstrs(X[:, j].sum() == 1 for j in range(J))
+
+# each machine can only take jobs that fit
+model.addConstrs((size[m, :] * X[m, :]).sum() <= capacity[m] for m in range(M))
+
+# print out the cuts as we solve
+def printCuts(e):
+    for c in e.cuts:
+        print(c)
+
+model.cbMipGetCutPool += printCuts
+
+# minimize total cost
+model.minimize((cost * X).sum())
+
+# print out solution (i.e., which jobs are assigned to which machines)
+print(model.getObjectiveValue())
+
+np.set_printoptions(formatter={'all': lambda x: str(x)})
+
+for m in range(M):
+    jobs_on_machine = np.nonzero(model.vals(X[m, :]) > 0)[0]
+    print(jobs_on_machine)

data/ext/lpsolver-highs/examples/chip.py

@@ -0,0 +1,43 @@
+# model and solve the LP
+#
+# maximize 10 Tables +  25 SetsOfChairs
+# s. t.       Tables +   2 SetsOfChairs <=  80: Assembly
+#             Tables +   4 SetsOfChairs <= 120: Finishing
+#             Tables >= 0; SetsOfChairs >= 0
+import highspy
+
+h = highspy.Highs()
+h.silent()
+
+items = ['Tables', 'SetsOfChairs']
+x = h.addVariables(items, obj = [10, 25], name = items)
+
+constrNames = ['Assembly', 'Finishing']
+cons = h.addConstrs(x['Tables'] + 2*x['SetsOfChairs'] <=  80, 
+                    x['Tables'] + 4*x['SetsOfChairs'] <= 120, name = constrNames)
+h.setMaximize()
+
+status = h.writeModel('Chip.lp')
+print(f"writeModel('Chip.lp') status = {status}")
+status = h.writeModel('Chip.mps')
+print(f"writeModel('Chip.mps') status = {status}\n")
+
+h.solve()
+
+for n, var in x.items():
+    print('Make', h.variableValue(var), n, ': Reduced cost', h.variableDual(var))
+
+print()
+print('Make', h.vals(x))
+print('Make', h.allVariableValues(), 'of', h.allVariableNames())
+print()
+
+for c in cons:
+    print('Constraint', c.name, 'has value', h.constrValue(c), 'and dual', h.constrDual(c))
+    
+print('Constraints have values', h.constrValues(cons), 'and duals', h.constrDuals(cons))
+print('Constraints have values', h.allConstrValues(), 'and duals', h.allConstrDuals())
+print()
+print('Optimal objective value is', h.getObjectiveValue())
+
+