Merge pull request #2524 from mathgeekcoder/highspy-getobj

[highspy] Add support for getObjective()

Author: jajhall

examples/callback_gap.py

@@ -1,6 +1,6 @@
 # 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 *
+from highspy import Highs
 import numpy as np
 
 #

examples/chip.py

@@ -9,35 +9,35 @@
 h = highspy.Highs()
 h.silent()
 
-items = ['Tables', 'Sets of chairs']
-x = h.addVariables(items, obj = [10, 20], name = items)
+items = ['Tables', 'SetsOfChairs']
+x = h.addVariables(items, obj = [10, 25], name = items)
 
 constrNames = ['Assembly', 'Finishing']
-cons = h.addConstrs(x['Tables'] + 2*x['Sets of chairs'] <=  80, 
-                    x['Tables'] + 4*x['Sets of chairs'] <= 120, name = constrNames)
-
+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('writeModel(\'Chip.lp\') status =', status)
+print(f"writeModel('Chip.lp') status = {status}")
 status = h.writeModel('Chip.mps')
-print('writeModel(\'Chip.mps\') status =', status)
+print(f"writeModel('Chip.mps') status = {status}\n")
 
 h.solve()
 
-
 for n, var in x.items():
-    print('Make', h.variableValue(var), h.variableName(var), ': Reduced cost', h.variableDual(var))
-    
-print('Make', h.variableValues(x.values()), 'of', h.variableNames(x.values()))
+    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())
 
 

examples/distillation.py

@@ -7,16 +7,13 @@
 #            TypeA >= 0; TypeB >= 0
 
 import highspy
-
-# For printing
-width = 4
-precision = 3
+width, precision = (4, 3)   # for printing
 
 h = highspy.Highs()
 h.silent()
 
 variableNames = ['TypeA', 'TypeB']
-x = h.addVariables(variableNames, obj = [8, 10], name = variableNames[0])
+x = h.addVariables(variableNames, obj = [8, 10], name = variableNames)
 
 constrNames = ['Product1', 'Product2', 'Product3']
 cons = h.addConstrs(2*x['TypeA'] + 2*x['TypeB'] >=  7,
@@ -26,53 +23,53 @@
 h.setMinimize()
 
 status = h.writeModel('Distillation.lp')
-print('writeModel(\'Distillation.lp\') status =', status)
+print(f"writeModel('Distillation.lp') status = {status}")
+
 status = h.writeModel('Distillation.mps')
-print('writeModel(\'Distillation.mps\') status =', status)
+print(f"writeModel('Distillation.mps') status = {status}")
+
 
 print()
-print('Solve as LP')
+print('# Solve as LP')
 
 h.solve()
 
 for name, var in x.items():
-    print('Use {0:.1f} of {1:s}: reduced cost {2:.6f}'.format(h.variableValue(var), h.variableName(var), h.variableDual(var)))
+    print(f'Use {h.variableValue(var):.1f} of {name}: reduced cost {h.variableDual(var):.6f}')
 
-print('Use', h.variableValues(x.values()), 'of', h.variableNames(x.values()))
+print()
+print('Use', h.vals(x))
 print('Use', h.allVariableValues(), 'of', h.allVariableNames())
+print()
 
 for c in cons:
     print(f"Constraint {c.name} has value {h.constrValue(c):{width}.{precision}} and dual  {h.constrDual(c):{width}.{precision}}")
 
 print('Constraints have values', h.constrValues(cons), 'and duals', h.constrDuals(cons))
 print('Constraints have values', h.allConstrValues(), 'and duals', h.allConstrDuals())
-
-for var in x.values():
-    print(f"Use {h.variableValue(var):{width}.{precision}} of {h.variableName(var)}")
 print(f"Optimal objective value is {h.getObjectiveValue():{width}.{precision}}")
 
-print()
-print('Solve as MIP')
 
-for var in x.values():
-    h.setInteger(var)
+print()
+print()
+print('# Solve as MIP')
 
+h.setInteger(x.values())
 h.solve()
 
 for var in x.values():
     print(f"Use {h.variableValue(var):{width}.{precision}} of {h.variableName(var)}")
 print(f"Optimal objective value is {h.getObjectiveValue():{width}.{precision}}")
 
 print()
-print('Solve as LP with Gomory cut')
+print()
+print('# Solve as LP with Gomory cut')
 
 # Make the variables continuous
-for var in x.values():
-    h.setContinuous(var)
+h.setContinuous(x.values())
 
 # Add Gomory cut
 h.addConstr(x['TypeA'] + x['TypeB'] >= 4, name = "Gomory")
-
 h.solve()
 
 for var in x.values():

examples/knapsack.py

@@ -1,55 +1,43 @@
+# Simple knapsack example to illustrate setSolution
+# max 8x1 + 5x2 + 3x3 + 11x4 + 7x5
+#     4x1 + 3x2 + 1x3 +  5x4 + 4x5 <= 11
+
 import numpy as np
 import highspy
 
+def print_solution(h, x):
+    print(f"Solution: ({', '.join(map(str, abs(h.val(x))))})")
+
 h = highspy.Highs()
-h.setOptionValue("output_flag", False);
-h.setOptionValue("presolve", "off");
-inf = highspy.kHighsInf
-lp = highspy.HighsLp()
-lp.sense_ = highspy.ObjSense.kMaximize
-lp.num_col_ = 5
-lp.num_row_ = 1
-lp.col_cost_ = np.array([8, 5, 3, 11, 7], dtype=np.double)
-lp.col_lower_ = np.array([0, 0, 0, 0, 0], dtype=np.double)
-lp.col_upper_ = np.array([1, 1, 1, 1, 1], dtype=np.double)
-lp.row_lower_ = np.array([-inf], dtype=np.double)
-lp.row_upper_ = np.array([11], dtype=np.double)
-lp.a_matrix_.format_ = highspy.MatrixFormat.kRowwise
-lp.a_matrix_.start_ = np.array([0, 5])
-lp.a_matrix_.index_ = np.array([0, 1, 2, 3, 4])
-lp.a_matrix_.value_ = np.array([4, 3, 1, 5, 4], dtype=np.double)
-lp.integrality_ = np.array([highspy.HighsVarType.kInteger, highspy.HighsVarType.kInteger, highspy.HighsVarType.kInteger, highspy.HighsVarType.kInteger, highspy.HighsVarType.kInteger])
-h.passModel(lp)
+h.silent()
+h.setOptionValue("presolve", "off")
 
-h.run()
-solution = h.getSolution()
-print(f"Solution: ({solution.col_value[0]}, {solution.col_value[1]}, {solution.col_value[2]}, {solution.col_value[3]}, {solution.col_value[4]})")
+x = h.addBinaries(5)
+h.addConstr((x * [4, 3, 1, 5, 4]).sum() <= 11)
+h.maximize((x * [8, 5, 3, 11, 7]).sum())
+    
+# solution is [1, 0, 1, 1, 0]
+print_solution(h, x)
 
-# Solution is [1, 0, 1, 1, 0]
 
 # Illustrate setSolution
-
 # First by passing back the optimal solution
-
 h.clearSolver()
-h.setSolution(solution)
+h.setSolution(h.getSolution())
 h.run()
-solution = h.getSolution()
-print(f"Solution: ({solution.col_value[0]}, {solution.col_value[1]}, {solution.col_value[2]}, {solution.col_value[3]}, {solution.col_value[4]})")
+print_solution(h, x)
 
 # Now passing back the optimal values of two variables as a sparse solution
 h.clearSolver()
 index = np.array([0, 3])
-value = np.array([1, 1], dtype=np.double)
+value = np.array([1, 1], dtype=np.float64)
 h.setSolution(2, index, value)
 h.run()
-solution = h.getSolution()
-print(f"Solution: ({solution.col_value[0]}, {solution.col_value[1]}, {solution.col_value[2]}, {solution.col_value[3]}, {solution.col_value[4]})")
+print_solution(h, x)
 
 # Test passing back the optimal value of one variable, and a non-optimal value of another, as a sparse solution in untyped array
 h.clearSolver()
 h.setSolution(2, np.array([0, 4]), np.array([1, 1]))
 h.run()
-solution = h.getSolution()
-print(f"Solution: ({solution.col_value[0]}, {solution.col_value[1]}, {solution.col_value[2]}, {solution.col_value[3]}, {solution.col_value[4]})")
+print_solution(h, x)
 

examples/multi_objective.py

@@ -0,0 +1,139 @@
+# Multi-objective binary knapsack example
+from highspy import Highs, HighsLinearObjective
+import numpy as np
+
+# Parameters
+capacity = 13
+
+# chosen such that applying each objective lexicographically gives a different solution
+profit = np.asarray([
+        [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1],
+        [1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0],
+        [1,1,1,1,1,1,1,1,1,0,1,0,0,0,0,0,0,0,0,0],
+        [1,1,1,1,0,1,0,0,1,1,0,0,0,1,1,1,0,0,0,0],
+
+    ], dtype=np.float64).reshape(4, 20)
+
+OBJECTIVES = profit.shape[0]
+ITEMS = profit.shape[1]
+
+def pretty_print(objective_values):
+    return '[ ' + ', '.join(map(lambda x: "{:2.0f}".format(x), objective_values)) + ' ]'
+
+#
+# individual optimization of each objective
+def individual_objectives(h, X):
+    print('## Individual:\n')
+    objective_values = []
+
+    for k in range(OBJECTIVES):
+        h.maximize(np.dot(X, profit[k,:]))
+        print(f'  Obj {k+1}: [{"".join(map(lambda x: "{:1.0f}".format(x), profit[k,:]))}]')
+        print(f'  Sol {k+1}: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]\n')
+        objective_values.append(h.getObjectiveValue())
+
+    print(f'  OBJ: {pretty_print(objective_values)}\n\n')
+
+#
+# manual implementation of lexicographic multi-objective optimization
+def manual_lexicographic(h, X):
+    print('## Manual lexicographic:\n')
+    cons = []
+    objs = np.dot(profit, X)
+
+    for k in range(OBJECTIVES):
+        h.maximize(objs[k])
+        print(f'  Obj {k+1}: [{"".join(map(lambda x: "{:1.0f}".format(x), profit[k,:]))}]')
+        print(f'  Sol {k+1}: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]\n')
+
+        # add constraint to ensure next solution are at least as good in this objective
+        cons.append(h.addConstr(np.dot(profit[k,:], X) >= h.getObjectiveValue()))
+
+    objective_values = h.vals(objs)
+    h.deleteRows(len(cons), cons)  # clean up constraints
+    print(f'  SOL: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]')
+    print(f'  OBJ: {pretty_print(objective_values)}\n\n')
+
+
+#
+# built-in lexicographic multi-objective optimization
+def highs_lexicographic(h, X):
+    print('## Built-in lexicographic:\n')
+    h.setOptionValue('blend_multi_objectives', False) # use lexicographic
+
+    for k in range(OBJECTIVES):
+        obj = HighsLinearObjective()
+        obj.coefficients = profit[k,:].tolist()
+        obj.weight = -1    # maximize
+        obj.priority = -k  # higher priority for lower k
+        obj.abs_tolerance = 0.01
+        obj.rel_tolerance = 0.001
+
+        h.addLinearObjective(obj)
+
+    h.solve()
+    print(f'  SOL: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]')
+    print(f'  OBJ: {pretty_print(np.dot(profit, h.vals(X)))}\n\n')
+
+    print(f'  Number of objectives: {h.getNumLinearObjectives()}')
+    for k in range(h.getNumLinearObjectives()):
+        obj = h.getLinearObjective(k)
+        print(f'  Obj {k+1}: weight={obj.weight}, priority={obj.priority}, abs_tol={obj.abs_tolerance}, rel_tol={obj.rel_tolerance}')
+    print('\n')
+
+    h.clearLinearObjectives()
+
+
+#
+# manual implementation of weighted multi-objective optimization
+def manual_weighted(h, X):
+    print('## Manual Weighted:\n')
+    weights = np.asarray([1.0/(k+1) for k in range(OBJECTIVES)], dtype=np.float64)
+    h.maximize(np.dot(weights[:,None] * profit, X).sum())
+
+    print(f'  SOL: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]')
+    print(f'  OBJ: {pretty_print(np.dot(profit, h.vals(X)))}\n')
+
+    print(f'  Obj: {h.getObjective()[0]}\n\n')
+
+
+#
+# built-in weighted multi-objective optimization
+def highs_weighted(h, X):
+    print('## Built-in Weighted:\n')
+    h.setOptionValue('blend_multi_objectives', True) # use weighted
+
+    for k in range(OBJECTIVES):
+        obj = HighsLinearObjective()
+        obj.coefficients = profit[k,:].tolist()
+        obj.weight = -1.0/(k+1)
+
+        h.addLinearObjective(obj)
+
+    h.solve()
+    print(f'  SOL: [{"".join(map(lambda x: "{:1.0f}".format(x), abs(h.vals(X))))}]')
+    print(f'  OBJ: {pretty_print(np.dot(profit, h.vals(X)))}\n')
+
+    print(f'  Number of objectives: {h.getNumLinearObjectives()}')
+    for k in range(h.getNumLinearObjectives()):
+        obj = h.getLinearObjective(k)
+        print(f'  Obj {k+1}: weight={obj.weight}, priority={obj.priority}, abs_tol={obj.abs_tolerance}, rel_tol={obj.rel_tolerance}')
+    print('\n')
+
+    h.clearLinearObjectives()
+
+
+if __name__ == "__main__":
+    h = Highs()
+    h.silent(True)
+
+    X = h.addBinaries(ITEMS)
+    h.addConstr(X.sum() <= capacity)
+
+    individual_objectives(h, X)
+
+    manual_lexicographic(h, X)
+    manual_weighted(h, X)
+
+    highs_lexicographic(h, X)
+    highs_weighted(h, X)

highs/Highs.h

@@ -159,6 +159,21 @@ class Highs {
   HighsStatus addLinearObjective(const HighsLinearObjective& linear_objective,
                                  const HighsInt iObj = -1);
 
+  /**
+   * @brief Get number of linear objectives from the incumbent model
+   */
+  HighsInt getNumLinearObjectives() const {
+    return multi_linear_objective_.size();
+  }
+
+  /**
+   * @brief Get a linear objective from the incumbent model
+   */
+  const HighsLinearObjective& getLinearObjective(const HighsInt idx) const {
+    assert(idx >= 0 && idx < int(multi_linear_objective_.size()));
+    return multi_linear_objective_[idx];
+  }
+
   /**
    * @brief Clear the multiple linear objective data
    */