address reviews

Author: Iroy30

python/cuopt/cuopt/linear_programming/problem.py

@@ -241,7 +241,9 @@ def __mul__(self, other):
                 qcoeffs = other.coefficients
                 vars = [self]
                 coeffs = [other.constant]
-                return QuadraticExpression(qvars1, qvars2, qcoeffs, vars, coeffs, 0.0)
+                return QuadraticExpression(
+                    qvars1, qvars2, qcoeffs, vars, coeffs, 0.0
+                )
             case _:
                 raise ValueError(
                     "Cannot multiply type %s with variable"
@@ -287,8 +289,11 @@ def __eq__(self, other):
             case _:
                 raise ValueError("Unsupported operation")
 
+
 class QuadraticExpression:
-    def __init__(self, qvars1, qvars2, qcoefficients, vars, coefficients, constant):
+    def __init__(
+        self, qvars1, qvars2, qcoefficients, vars, coefficients, constant
+    ):
         self.qvars1 = qvars1
         self.qvars2 = qvars2
         self.qcoefficients = qcoefficients
@@ -388,19 +393,38 @@ def __add__(self, other):
             case int() | float():
                 # Update just the constant value
                 return QuadraticExpression(
-                    self.qvars1, self.qvars2, self.qcoefficients, self.vars, self.coefficients, self.constant + float(other)
+                    self.qvars1,
+                    self.qvars2,
+                    self.qcoefficients,
+                    self.vars,
+                    self.coefficients,
+                    self.constant + float(other),
                 )
             case Variable():
                 # Append just a variable with coefficient 1.0
                 vars = self.vars + [other]
                 coeffs = self.coefficients + [1.0]
-                return QuadraticExpression(self.qvars1, self.qvars2, self.qcoefficients, vars, coeffs, self.constant)
+                return QuadraticExpression(
+                    self.qvars1,
+                    self.qvars2,
+                    self.qcoefficients,
+                    vars,
+                    coeffs,
+                    self.constant,
+                )
             case LinearExpression():
                 # Append all linear variables, coefficients and constants
                 vars = self.vars + other.vars
                 coeffs = self.coefficients + other.coefficients
                 constant = self.constant + other.constant
-                return QuadraticExpression(self.qvars1, self.qvars2, self.qcoefficients, vars, coeffs, constant)
+                return QuadraticExpression(
+                    self.qvars1,
+                    self.qvars2,
+                    self.qcoefficients,
+                    vars,
+                    coeffs,
+                    constant,
+                )
             case QuadraticExpression():
                 # Append all quadratic variables, coefficients and constants
                 qvars1 = self.qvars1 + other.qvars1
@@ -409,8 +433,14 @@ def __add__(self, other):
                 vars = self.vars + other.vars
                 coeffs = self.coefficients + other.coefficients
                 constant = self.constant + other.constant
-                return QuadraticExpression(qvars1, qvars2, qcoeffs, vars, coeffs, constant)
-
+                return QuadraticExpression(
+                    qvars1, qvars2, qcoeffs, vars, coeffs, constant
+                )
+            case _:
+                raise ValueError(
+                    "Can't add type %s to Quadratic Expression"
+                    % type(other).__name__
+                )
 
     def __radd__(self, other):
         return self + other
@@ -457,13 +487,25 @@ def __sub__(self, other):
             case int() | float():
                 # Update just the constant value
                 return QuadraticExpression(
-                    self.qvars1, self.qvars2, self.qcoefficients, self.vars, self.coefficients, self.constant - float(other)
+                    self.qvars1,
+                    self.qvars2,
+                    self.qcoefficients,
+                    self.vars,
+                    self.coefficients,
+                    self.constant - float(other),
                 )
             case Variable():
                 # Append just a variable with coefficient -1.0
                 vars = self.vars + [other]
                 coeffs = self.coefficients + [-1.0]
-                return QuadraticExpression(self.qvars1, self.qvars2, self.qcoefficients, vars, coeffs, self.constant)
+                return QuadraticExpression(
+                    self.qvars1,
+                    self.qvars2,
+                    self.qcoefficients,
+                    vars,
+                    coeffs,
+                    self.constant,
+                )
             case LinearExpression():
                 # Append all linear variables, coefficients and constants
                 vars = self.vars + other.vars
@@ -473,7 +515,14 @@ def __sub__(self, other):
                 for i in other.coefficients:
                     coeffs.append(-1.0 * i)
                 constant = self.constant - other.constant
-                return QuadraticExpression(self.qvars1, self.qvars2, self.qcoefficients, vars, coeffs, constant)
+                return QuadraticExpression(
+                    self.qvars1,
+                    self.qvars2,
+                    self.qcoefficients,
+                    vars,
+                    coeffs,
+                    constant,
+                )
             case QuadraticExpression():
                 # Append all quadratic variables, coefficients and constants
                 vars = self.vars + other.vars
@@ -490,8 +539,14 @@ def __sub__(self, other):
                     qcoeffs.append(i)
                 for i in other.qcoefficients:
                     qcoeffs.append(-1.0 * i)
-                return QuadraticExpression(qvars1, qvars2, qcoeffs, vars, coeffs, constant)
-
+                return QuadraticExpression(
+                    qvars1, qvars2, qcoeffs, vars, coeffs, constant
+                )
+            case _:
+                raise ValueError(
+                    "Can't sub type %s from Quadratic Expression"
+                    % type(other).__name__
+                )
 
     def __rsub__(self, other):
         # other - self  -> other + self * -1.0
@@ -520,9 +575,18 @@ def __mul__(self, other):
         match other:
             case int() | float():
                 coeffs = [coeff * float(other) for coeff in self.coefficients]
-                qcoeffs = [qcoeff * float(other) for qcoeff in self.qcoefficients]
+                qcoeffs = [
+                    qcoeff * float(other) for qcoeff in self.qcoefficients
+                ]
                 constant = self.constant * float(other)
-                return QuadraticExpression(self.qvars1, self.qvars2, qcoeffs, self.vars, coeffs, constant)
+                return QuadraticExpression(
+                    self.qvars1,
+                    self.qvars2,
+                    qcoeffs,
+                    self.vars,
+                    coeffs,
+                    constant,
+                )
             case _:
                 raise ValueError(
                     "Can't multiply type %s by QuadraticExpresson"
@@ -555,9 +619,18 @@ def __truediv__(self, other):
         match other:
             case int() | float():
                 coeffs = [coeff / float(other) for coeff in self.coefficients]
-                qcoeffs = [qcoeff / float(other) for qcoeff in self.qcoefficients]
+                qcoeffs = [
+                    qcoeff / float(other) for qcoeff in self.qcoefficients
+                ]
                 constant = self.constant / float(other)
-                return QuadraticExpression(self.qvars1, self.qvars2, qcoeffs, self.vars, coeffs, constant)
+                return QuadraticExpression(
+                    self.qvars1,
+                    self.qvars2,
+                    qcoeffs,
+                    self.vars,
+                    coeffs,
+                    constant,
+                )
             case _:
                 raise ValueError(
                     "Can't divide LinearExpression by type %s"
@@ -783,11 +856,17 @@ def __imul__(self, other):
                     for j in range(len(other.vars)):
                         qvars1.append(self.vars[i])
                         qvars2.append(other.vars[j])
-                        qcoeffs.append(self.coefficients[i] * other.coefficients[j])
+                        qcoeffs.append(
+                            self.coefficients[i] * other.coefficients[j]
+                        )
                 vars = self.vars + other.vars
-                coeffs = [other.constant * i for i in self.coefficients] + [self.constant * i for i in other.coefficients]
+                coeffs = [other.constant * i for i in self.coefficients] + [
+                    self.constant * i for i in other.coefficients
+                ]
                 constant = self.constant * other.constant
-                return QuadraticExpression(qvars1, qvars2, qcoeffs, vars, coeffs, constant)
+                return QuadraticExpression(
+                    qvars1, qvars2, qcoeffs, vars, coeffs, constant
+                )
             case _:
                 raise ValueError(
                     "Can't multiply type %s by LinearExpresson"
@@ -807,11 +886,17 @@ def __mul__(self, other):
                     for j in range(len(other.vars)):
                         qvars1.append(self.vars[i])
                         qvars2.append(other.vars[j])
-                        qcoeffs.append(self.coefficients[i] * other.coefficients[j])
+                        qcoeffs.append(
+                            self.coefficients[i] * other.coefficients[j]
+                        )
                 vars = self.vars + other.vars
-                coeffs = [other.constant * i for i in self.coefficients] + [self.constant * i for i in other.coefficients]
+                coeffs = [other.constant * i for i in self.coefficients] + [
+                    self.constant * i for i in other.coefficients
+                ]
                 constant = self.constant * other.constant
-                return QuadraticExpression(qvars1, qvars2, qcoeffs, vars, coeffs, constant)
+                return QuadraticExpression(
+                    qvars1, qvars2, qcoeffs, vars, coeffs, constant
+                )
             case Variable():
                 return other * self
 
@@ -1361,7 +1446,11 @@ def setObjective(self, expr, sense=MINIMIZE):
                         sum_coeff
                     )
                 self.ObjConstant = expr.constant
-                self.objective_qcoo_matrix = expr.qvars1, expr.qvars2, expr.qcoefficients
+                self.objective_qcoo_matrix = (
+                    expr.qvars1,
+                    expr.qvars2,
+                    expr.qcoefficients,
+                )
             case _:
                 raise ValueError(
                     "Objective must be a LinearExpression or a constant"
@@ -1523,7 +1612,12 @@ def Obj(self):
         if not self.objective_qcoo_matrix:
             return LinearExpression(self.vars, coeffs, self.ObjConstant)
         else:
-            return QuadraticExpression(*self.objective_qcoo_matrix, self.vars, coeffs, self.ObjConstant)
+            return QuadraticExpression(
+                *self.objective_qcoo_matrix,
+                self.vars,
+                coeffs,
+                self.ObjConstant,
+            )
 
     def getCSR(self):
         """
@@ -1556,18 +1650,19 @@ def getQcsr(self):
             row_dict = Qdict[var1.index]
             var2 = vars2[i]
             coeff = coeffs[i]
-            row_dict[var2.index] = row_dict[var2.index] + coeff if var2.index in row_dict else coeff
+            row_dict[var2.index] = (
+                row_dict[var2.index] + coeff
+                if var2.index in row_dict
+                else coeff
+            )
         for i in range(0, self.NumVariables):
             if i in Qdict:
-                Qcsr_dict["column_indices"].extend(
-                    list(Qdict[i].keys())
-                )
+                Qcsr_dict["column_indices"].extend(list(Qdict[i].keys()))
                 Qcsr_dict["values"].extend(list(Qdict[i].values()))
             Qcsr_dict["row_pointers"].append(len(Qcsr_dict["column_indices"]))
         self.objective_qcsr_matrix = Qcsr_dict
         return self.dict_to_object(Qcsr_dict)
 
-
     def relax(self):
         """
         Relax a MIP problem into an LP problem and return the relaxed model.

python/cuopt/cuopt/tests/linear_programming/test_python_API.py

@@ -675,7 +675,7 @@ def test_quadratic_expression_and_matrix():
 
     # Test Quadratic Expressions
     expr1 = x * x  # var * var
-    expr2 = expr1 + y*z + 2  # QP + QP + const
+    expr2 = expr1 + y * z + 2  # QP + QP + const
     expr3 = expr2 * 4  # QP * const
 
     assert expr1.getVariables() == [(x, x)]
@@ -697,10 +697,12 @@ def test_quadratic_expression_and_matrix():
     assert expr4.getLinearExpression().getVariables() == [y]
     assert expr4.getLinearExpression().getCoefficients() == [-1]
 
-    expr5 = z + 7*y + 1  # LP
+    expr5 = z + 7 * y + 1  # LP
     expr6 = y * expr5  # var * LP
-    expr7 = expr5 - x*x  # LP - QP
-    expr8 = expr4 - expr5  # QP - LP # x2 + yz + 2 - y - 7y -z - 1 + 7y2 + yz + y
+    expr7 = expr5 - x * x  # LP - QP
+    expr8 = (
+        expr4 - expr5
+    )  # QP - LP # x2 + yz + 2 - y - 7y -z - 1 + 7y2 + yz + y
     expr8 += expr6  # QP + QP
 
     assert expr6.getVariable1(0) is y
@@ -725,7 +727,7 @@ def test_quadratic_expression_and_matrix():
     assert expr8.getLinearExpression().getConstant() == 1
     assert expr8.getLinearExpression().getCoefficients() == [-1, -7, -1, 1]
 
-    expr9 = expr5 * (3*x - y + z + 3)  # LP * LP
+    expr9 = expr5 * (3 * x - y + z + 3)  # LP * LP
     # expr9 = 21*y*x + 7*y*z + 21*y - 7*y*y + 3*x + z + 3 - y + 3*z*x + z*z +3*z - z*y
 
     qvariables = [(y, x), (y, y), (y, z), (z, x), (z, y), (z, z)]
@@ -757,23 +759,57 @@ def test_quadratic_expression_and_matrix():
     assert Qcsr.values == exp_vals
 
 
-def test_quadratic_objective():
-
+def test_quadratic_objective_1():
     # Minimize x1 ^2 + 4 x2 ^2 - 8 x1 - 16 x2
     # subject to x1 + x2 >= 5
     #         x1 >= 3
     #         x2 >= 0
 
     problem = Problem()
     x1 = problem.addVariable(lb=3.0, name="x")
-    x2 = problem.addVariable(lb = 0, name="y")
+    x2 = problem.addVariable(lb=0, name="y")
 
     problem.addConstraint(x1 + x2 >= 5)
-    problem.setObjective(x1*x1 + 4*x2*x2 - 8*x1 - 16*x2)
+    problem.setObjective(x1 * x1 + 4 * x2 * x2 - 8 * x1 - 16 * x2)
 
     problem.solve()
 
     assert problem.Status.name == "Optimal"
     assert x1.getValue() == pytest.approx(4.0)
     assert x2.getValue() == pytest.approx(2.0)
-    assert problem.ObjValue ==  pytest.approx(-32.0)
+    assert problem.ObjValue == pytest.approx(-32.0)
+
+
+def test_quadratic_objective_2():
+    # Minimize 4 x1^2 + 2 x2^2 + 3 x3^2 + 1.5 x1 x3 - 2 x1 + 0.5 x2 - x3
+    # subject to x1 + 2*x2 + x3 <= 3
+    #         x1 >= 0
+    #         x2 >= 0
+    #         x3 >= 0
+
+    problem = Problem()
+    x1 = problem.addVariable(lb=0, name="x")
+    x2 = problem.addVariable(lb=0, name="y")
+    x3 = problem.addVariable(lb=0, name="z")
+
+    problem.addConstraint(x1 + 2 * x2 + x3 <= 3)
+    problem.setObjective(
+        2 * x1 * x1
+        + 2 * x2 * x2
+        + 3 * x3 * x3
+        + 1.5 * x1 * x3
+        - 2 * x1
+        + 0.5 * x2
+        - 2 * x1 * x2
+        - 1.0 * x3
+        + 2 * x1 * x1
+        + 2 * x1 * x2
+    )
+
+    problem.solve()
+
+    assert problem.Status.name == "Optimal"
+    assert x1.getValue() == pytest.approx(0.2295081)
+    assert x2.getValue() == pytest.approx(0.0000000, abs=0.000001)
+    assert x3.getValue() == pytest.approx(0.1092896)
+    assert problem.ObjValue == pytest.approx(-0.284153)