Added New Method for Simplifying ScalarConstraints (This needs to be more thoroughly thought out and documented)

Author: kwesiRutledge

README.md

@@ -133,33 +133,15 @@ code. Hopefully, this is avoided using this format.
 * [X] Create New AddConstr methods which work for vector constraints
 * [ ] Mult
   * [ ] General Function (in operators.go)
-    * [ ] Methods for
-        * [X] Scalars
-            * [X] Constant
-            * [X] Var
-            * [X] ScalarLinearExpression
-            * [X] QuadraticExpression
-        * [ ] Vectors
-            * [ ] Vector Constant
-            * [ ] VarVector
-            * [ ] VectorLinearExpression
 * [ ] Plus
     * [ ] General Function (in operators.go)
 * [ ] Introducing Optional Input for Variable Name to Var/VarVector
 * [ ] Consider renaming VarVector to VectorVar
 * [ ] Decide whether or not we really need the Coeffs() method (What is it doing?)
-* [ ] Create function for easily creating MatDense:
-    * [ ] ones matrices
-* [ ] Create function for:
-    * [ ] IsScalar()
-    * [ ] IsVector()
-* [X] VectorConstraint
-    * [X] AtVec()
 * [ ] Write changes to all AtVec() methods to output both elements AND errors (so we can detect out of length calls)
 * [ ] Determine whether or not to keep the Solution and Solver() interfaces in this module. It seems like they can be solver-specific.
 * [ ] Introduce MatrixVar object
-* [ ] Add The Following to the Expression Interface
-  * [ ] Comparison
-  * [ ] LessEq
-  * [ ] GreaterEq
-  * [ ] Eq
+* [ ] Add Check() to:
+  * [ ] Expression
+  * [ ] ScalarExpression
+  * [ ] VectorExpression interfaces

optim/scalar_constraint.go

@@ -1,5 +1,7 @@
 package optim
 
+import "fmt"
+
 // ScalarConstraint represnts a linear constraint of the form x <= y, x >= y, or
 // x == y. ScalarConstraint uses a left and right hand side expressions along with a
 // constraint sense (<=, >=, ==) to represent a generalized linear constraint
@@ -40,6 +42,70 @@ func (sc ScalarConstraint) IsLinear() (bool, error) {
 	return true, nil
 }
 
+/*
+Simplify
+Description:
+
+	Moves all of the variables of the ScalarConstraint to its
+	left hand side.
+*/
+func (sc ScalarConstraint) Simplify() (ScalarConstraint, error) {
+	// Create LHS
+	newLHS := sc.LeftHandSide
+
+	// Algorithm
+	switch right := sc.RightHandSide.(type) {
+	case K:
+		return sc, nil
+	case Variable:
+		newLHS, err := newLHS.Plus(right.Multiply(-1.0))
+		if err != nil {
+			return sc, err
+		}
+		newLHSAsSE, _ := ToScalarExpression(newLHS)
+
+		return ScalarConstraint{
+			LeftHandSide:  newLHSAsSE,
+			RightHandSide: K(0),
+			Sense:         sc.Sense,
+		}, nil
+	case ScalarLinearExpr:
+		rightWithoutConstant := right
+		rightWithoutConstant.C = 0.0
+
+		newLHS, err := newLHS.Plus(rightWithoutConstant.Multiply(-1.0))
+		if err != nil {
+			return sc, err
+		}
+		newLHSAsSE, _ := ToScalarExpression(newLHS)
+
+		return ScalarConstraint{
+			LeftHandSide:  newLHSAsSE,
+			RightHandSide: K(right.C),
+			Sense:         sc.Sense,
+		}, nil
+	case ScalarQuadraticExpression:
+		rightWithoutConstant := right
+		rightWithoutConstant.C = 0.0
+
+		newLHS, err := newLHS.Plus(rightWithoutConstant.Multiply(-1.0))
+		if err != nil {
+			return sc, err
+		}
+		newLHSAsSE, _ := ToScalarExpression(newLHS)
+
+		return ScalarConstraint{
+			LeftHandSide:  newLHSAsSE,
+			RightHandSide: K(right.C),
+			Sense:         sc.Sense,
+		}, nil
+
+	default:
+		return sc, fmt.Errorf("unexpected type of right hand side: %T", right)
+	}
+
+}
+
 // ConstrSense represents if the constraint x <= y, x >= y, or x == y. For easy
 // integration with Gurobi, the senses have been encoding using a byte in
 // the same way Gurobi encodes the constraint senses.

testing/optim/scalar_constraint_test.go

@@ -98,3 +98,43 @@ func TestScalarConstraint_IsLinear2(t *testing.T) {
 	}
 
 }
+
+/*
+TestScalarConstraint_Simplify1
+Description:
+
+	Attempts to simplify the constraint between
+	a scalar linear epression and a scalar linear expression.
+*/
+func TestScalarConstraint_Simplify1(t *testing.T) {
+	// Constants
+	m := optim.NewModel("scalar-constraint-test1")
+	vv1 := m.AddVariableVector(3)
+	sle2 := optim.ScalarLinearExpr{
+		L: optim.OnesVector(vv1.Len()),
+		X: vv1,
+		C: 2.0,
+	}
+	sle3 := optim.ScalarLinearExpr{
+		L: *mat.NewVecDense(vv1.Len(), []float64{1.0, 2.0, 3.0}),
+		X: vv1,
+		C: 1.0,
+	}
+
+	// Create sles
+	sc1 := optim.ScalarConstraint{
+		LeftHandSide:  sle2,
+		RightHandSide: sle3,
+		Sense:         optim.SenseEqual,
+	}
+
+	// Attempt to simplify
+	sc2, err := sc1.Simplify()
+	if err != nil {
+		t.Errorf("unexpected error during simplify(): %v", err)
+	}
+
+	if float64(sc2.RightHandSide.(optim.K)) != 1.0 {
+		t.Errorf("Remainder on LHS was not contained properly")
+	}
+}