Merge pull request #4 from MatProGo-dev/kr-feature-multiply1

Redid Expressions So That Multiply(), Plus(), Eq(), LessEq(), Greater…

Author: kwesiRutledge

README.md

@@ -157,4 +157,9 @@ code. Hopefully, this is avoided using this format.
     * [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
+* [ ] Introduce MatrixVar object
+* [ ] Add The Following to the Expression Interface
+  * [ ] Comparison
+  * [ ] LessEq
+  * [ ] GreaterEq
+  * [ ] Eq

optim/constant.go

@@ -52,47 +52,52 @@ func (c K) Constant() float64 {
 
 // Plus adds the current expression to another and returns the resulting
 // expression
-func (c K) Plus(e interface{}, errors ...error) (ScalarExpression, error) {
+func (c K) Plus(rightIn interface{}, errors ...error) (Expression, error) {
 	// Input Processing
 	err := CheckErrors(errors)
 	if err != nil {
 		return c, err
 	}
 
+	if IsExpression(rightIn) {
+		rightAsE, _ := ToExpression(rightIn)
+		err = CheckDimensionsInAddition(c, rightAsE)
+		if err != nil {
+			return c, err
+		}
+	}
+
 	// Switching based on input type
-	switch e.(type) {
+	switch right := rightIn.(type) {
 	case K:
-		eAsK, _ := e.(K)
-		return K(c.Constant() + eAsK.Constant()), nil
+		return K(c.Constant() + right.Constant()), nil
 	case Variable:
-		eAsVar := e.(Variable)
-		return eAsVar.Plus(c)
+		return right.Plus(c)
 	case ScalarLinearExpr:
-		eAsSLE := e.(ScalarLinearExpr)
-		return eAsSLE.Plus(c)
+		return right.Plus(c)
 	case ScalarQuadraticExpression:
-		return e.(ScalarQuadraticExpression).Plus(c) // Very compact, but potentially confusing to read?
+		return right.Plus(c) // Very compact, but potentially confusing to read?
 	default:
-		return c, fmt.Errorf("Unexpected type in K.Plus() for constant %v: %T", e, e)
+		return c, fmt.Errorf("Unexpected type in K.Plus() for constant %v: %T", right, right)
 	}
 }
 
 // LessEq returns a less than or equal to (<=) constraint between the
 // current expression and another
-func (c K) LessEq(rhsIn interface{}, errors ...error) (ScalarConstraint, error) {
-	return c.Comparison(rhsIn, SenseLessThanEqual, errors...)
+func (c K) LessEq(rightIn interface{}, errors ...error) (Constraint, error) {
+	return c.Comparison(rightIn, SenseLessThanEqual, errors...)
 }
 
 // GreaterEq returns a greater than or equal to (>=) constraint between the
 // current expression and another
-func (c K) GreaterEq(rhsIn interface{}, errors ...error) (ScalarConstraint, error) {
-	return c.Comparison(rhsIn, SenseGreaterThanEqual, errors...)
+func (c K) GreaterEq(rightIn interface{}, errors ...error) (Constraint, error) {
+	return c.Comparison(rightIn, SenseGreaterThanEqual, errors...)
 }
 
 // Eq returns an equality (==) constraint between the current expression
 // and another
-func (c K) Eq(rhsIn interface{}, errors ...error) (ScalarConstraint, error) {
-	return c.Comparison(rhsIn, SenseEqual, errors...)
+func (c K) Eq(rightIn interface{}, errors ...error) (Constraint, error) {
+	return c.Comparison(rightIn, SenseEqual, errors...)
 }
 
 /*
@@ -101,7 +106,7 @@ Description:
 
 	This method compares the receiver with expression rhs in the sense provided by sense.
 */
-func (c K) Comparison(rhsIn interface{}, sense ConstrSense, errors ...error) (ScalarConstraint, error) {
+func (c K) Comparison(rhsIn interface{}, sense ConstrSense, errors ...error) (Constraint, error) {
 	// InputProcessing
 	err := CheckErrors(errors)
 	if err != nil {
@@ -237,3 +242,7 @@ func (c K) Dims() []int {
 func (c K) Check() error {
 	return nil
 }
+
+func (c K) Transpose() Expression {
+	return c
+}

optim/constraint.go

@@ -8,9 +8,11 @@ Description:
 */
 
 type Constraint interface {
+	Left() Expression
+	Right() Expression
 }
 
-func IsConstraint(c Constraint) bool {
+func IsConstraint(c interface{}) bool {
 	switch c.(type) {
 	case ScalarConstraint:
 		return true

optim/expression.go

@@ -5,7 +5,7 @@ import (
 )
 
 /*
-expression.go
+matrix_expression.go
 Description:
 	This file holds all of the functions and methods related to the Expression
 	interface.
@@ -27,25 +27,31 @@ type Expression interface {
 	// Dims returns a slice describing the true dimensions of a given expression (scalar, vector, or matrix)
 	Dims() []int
 
-	//// Plus adds the current expression to another and returns the resulting
-	//// expression
-	// Plus(e Expression, extras interface{}) (Expression, error)
-	//
-	//// Mult multiplies the current expression to another and returns the
-	//// resulting expression
-	//Multiply(c interface{}) (Expression, error)
-	//
-	//// LessEq returns a less than or equal to (<=) constraint between the
-	//// current expression and another
-	//LessEq(e Expression) Constraint
-	//
-	//// GreaterEq returns a greater than or equal to (>=) constraint between the
-	//// current expression and another
-	//GreaterEq(e Expression) Constraint
-	//
-	//// Eq returns an equality (==) constraint between the current expression
-	//// and another
-	//Eq(e ScalarExpression) *ScalarConstraint
+	// Plus adds the current expression to another and returns the resulting
+	// expression
+	Plus(e interface{}, errors ...error) (Expression, error)
+
+	// Multiply multiplies the current expression to another and returns the
+	// resulting expression
+	Multiply(c interface{}, errors ...error) (Expression, error)
+
+	// Transpose transposes the given expression
+	Transpose() Expression
+
+	// LessEq returns a less than or equal to (<=) constraint between the
+	// current expression and another
+	LessEq(rightIn interface{}, errors ...error) (Constraint, error)
+
+	// GreaterEq returns a greater than or equal to (>=) constraint between the
+	// current expression and another
+	GreaterEq(rightIn interface{}, errors ...error) (Constraint, error)
+
+	// Eq returns an equality (==) constraint between the current expression
+	// and another
+	Eq(rightIn interface{}, errors ...error) (Constraint, error)
+
+	// Comparison
+	Comparison(rightIn interface{}, sense ConstrSense, errors ...error) (Constraint, error)
 }
 
 /*
@@ -82,3 +88,20 @@ func CheckDimensionsInMultiplication(left, right Expression) error {
 	// If dimensions match, then return nothing.
 	return nil
 }
+
+func CheckDimensionsInAddition(left, right Expression) error {
+	// Check that the size of columns in left and right agree
+	dimsAreMatched := (left.Dims()[0] == right.Dims()[0]) && (left.Dims()[1] == right.Dims()[1])
+	dimsAreMatched = dimsAreMatched || IsScalarExpression(left)
+	dimsAreMatched = dimsAreMatched || IsScalarExpression(right)
+
+	if !dimsAreMatched {
+		return DimensionError{
+			Operation: "Plus",
+			Arg1:      left,
+			Arg2:      right,
+		}
+	}
+	// If dimensions match, then return nothing.
+	return nil
+}

optim/model.go

@@ -132,48 +132,40 @@ func (m *Model) AddBinaryVariableMatrix(rows, cols int) [][]Variable {
 }
 
 // AddConstr adds the given constraint to the model.
-func (m *Model) AddConstraint(constr Constraint, extras ...interface{}) error {
+func (m *Model) AddConstraint(constr Constraint, errors ...error) error {
 	// Constants
-	nExtraArguments := len(extras)
 
 	// Input Processing
-	switch {
-	case nExtraArguments > 1:
-		// Do nothing, but report an error
-		return fmt.Errorf(
-			"The optimizer tried to add a constraint using a bad call to AddConstr! Skipping this constraint: %v , because of extra inputs %v",
-			constr,
-			extras,
-		)
-	case nExtraArguments == 1:
-		switch extra0 := extras[0].(type) {
-		case error:
-			if extra0 != nil {
-				return fmt.Errorf(
-					"There was an error computing constraint %v: %v",
-					constr, extra0,
-				)
-			}
-		case nil:
-			// Do nothing
-		default:
-			return fmt.Errorf(
-				"There was an unexpected type input to AddConstraint(): %T (%v)",
-				extra0, extra0,
-			)
-		}
+	err := CheckErrors(errors)
+	if err != nil {
+		return err
 	}
-	// If no extras are given, then move on to last part.
 
 	// Algorithm
 	m.Constraints = append(m.Constraints, constr)
 	return nil
 }
 
-// SetObjective sets the objective of the model given an expression and
-// objective sense.
-func (m *Model) SetObjective(e ScalarExpression, sense ObjSense) {
-	m.Obj = NewObjective(e, sense)
+/*
+SetObjective
+Description:
+	sets the objective of the model given an expression and
+	objective sense.
+Notes:
+	To make this function easier to parse, we will assume an expression
+	is given, even though objectives are normally scalars.
+*/
+
+func (m *Model) SetObjective(e Expression, sense ObjSense) error {
+	// Input Processing
+	se, err := ToScalarExpression(e)
+	if err != nil {
+		return fmt.Errorf("trouble parsing input expression: %v", err)
+	}
+
+	// Return
+	m.Obj = NewObjective(se, sense)
+	return nil
 }
 
 //// Optimize optimizes the model using the given solver type and returns the

optim/operators.go

@@ -27,7 +27,7 @@ func LessEq(lhs, rhs interface{}) (Constraint, error) {
 }
 
 // GreaterEq returns a constraint representing lhs >= rhs
-func GreaterEq(lhs, rhs ScalarExpression) (Constraint, error) {
+func GreaterEq(lhs, rhs interface{}) (Constraint, error) {
 	return Comparison(lhs, rhs, SenseGreaterThanEqual)
 }
 
@@ -42,31 +42,24 @@ Usage:
 	constr, err := Comparison(expr1, expr2, SenseGreaterThanEqual)
 */
 func Comparison(lhs, rhs interface{}, sense ConstrSense) (Constraint, error) {
-	// Constants
+	// Input Processing
+	var err error
+	left0, err := ToExpression(lhs)
+	if err != nil {
+		return ScalarConstraint{}, fmt.Errorf("lhs is not a valid expression: %v", err)
+	}
 
 	// Algorithm
-	switch lhs0 := lhs.(type) {
-	case float64:
-		// Convert lhs to K
-		lhsAsK := K(lhs0)
-
-		// Create constraint
-		return Comparison(lhsAsK, rhs, sense)
-	case mat.VecDense:
-		// Convert lhs to KVector.
-		lhsAsKVector := KVector(lhs0)
-
-		// Create constraint
-		return lhsAsKVector.Comparison(rhs, sense)
+	switch left := left0.(type) {
 	case ScalarExpression:
 		rhsAsScalarExpression, _ := rhs.(ScalarExpression)
 		return ScalarConstraint{
-			lhs0,
+			left,
 			rhsAsScalarExpression,
 			sense,
 		}, nil
 	case VectorExpression:
-		return lhs0.Comparison(rhs, sense)
+		return left.Comparison(rhs, sense)
 	default:
 		return nil, fmt.Errorf("Comparison in sense '%v' is not defined for lhs type %T and rhs type %T!", sense, lhs, rhs)
 	}

optim/scalar_constraint.go

@@ -9,6 +9,14 @@ type ScalarConstraint struct {
 	Sense         ConstrSense
 }
 
+func (sc ScalarConstraint) Left() Expression {
+	return sc.LeftHandSide
+}
+
+func (sc ScalarConstraint) Right() Expression {
+	return sc.RightHandSide
+}
+
 // 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.

optim/scalar_expression.go

@@ -26,35 +26,38 @@ type ScalarExpression interface {
 
 	// Plus adds the current expression to another and returns the resulting
 	// expression
-	Plus(e interface{}, errors ...error) (ScalarExpression, error)
+	Plus(rightIn interface{}, errors ...error) (Expression, error)
 
 	// Mult multiplies the current expression to another and returns the
 	// resulting expression
 	//Mult(c float64, errors ...error) (Expression, error)
 
 	// LessEq returns a less than or equal to (<=) constraint between the
 	// current expression and another
-	LessEq(rhsIn interface{}, errors ...error) (ScalarConstraint, error)
+	LessEq(rhsIn interface{}, errors ...error) (Constraint, error)
 
 	// GreaterEq returns a greater than or equal to (>=) constraint between the
 	// current expression and another
-	GreaterEq(rhsIn interface{}, errors ...error) (ScalarConstraint, error)
+	GreaterEq(rhsIn interface{}, errors ...error) (Constraint, error)
 
 	// Eq returns an equality (==) constraint between the current expression
 	// and another
-	Eq(rhsIn interface{}, errors ...error) (ScalarConstraint, error)
+	Eq(rhsIn interface{}, errors ...error) (Constraint, error)
 
 	//Comparison
 	// Compares the receiver expression rhs with the expression rhs in the sense of sense.
-	Comparison(rhsIn interface{}, sense ConstrSense, errors ...error) (ScalarConstraint, error)
+	Comparison(rhsIn interface{}, sense ConstrSense, errors ...error) (Constraint, error)
 
 	//Multiply
 	// Multiplies the given scalar expression with another expression
-	Multiply(term1 interface{}, errors ...error) (Expression, error)
+	Multiply(rightIn interface{}, errors ...error) (Expression, error)
 
 	//Dims
 	// Returns the dimensions of the scalar expression (should always be 1,1)
 	Dims() []int
+
+	//Transpose returns the transpose of the given vector expression
+	Transpose() Expression
 }
 
 // NewExpr returns a new expression with a single additive constant value, c,