Merge pull request #10 from MatProGo-dev/kr-feature-panics1

Introducing More Methods for PolynomialLike objects and Many More Tests

Author: kwesiRutledge

Diff for: smErrors/dimension_error.go

@@ -70,6 +70,29 @@ func CheckDimensionsInAddition(left, right MatrixLike) error {
 	return nil
 }
 
+/*
+CheckDimensionsInSubtraction
+Description:
+
+	This function checks that the dimensions of the left and right expressions
+*/
+func CheckDimensionsInSubtraction(left, right MatrixLike) 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: "Minus",
+			Arg1:      left,
+			Arg2:      right,
+		}
+	}
+	// If dimensions match, then return nothing.
+	return nil
+}
+
 /*
 CheckDimensionsInMultiplication
 Description:

Diff for: symbolic/constant.go

@@ -92,14 +92,17 @@ func (c K) Plus(rightIn interface{}) Expression {
 			panic(fmt.Errorf("error in second argument to %v.Plus: %v", c, err))
 		}
 
-		err = smErrors.CheckDimensionsInAddition(c, rightAsE)
-		if err != nil {
-			panic(err)
-		}
+		// Dimension checks should be fine because c is a scalar.
+		//err = smErrors.CheckDimensionsInAddition(c, rightAsE)
+		//if err != nil {
+		//	panic(err)
+		//}
 	}
 
 	// Switching based on input type
 	switch right := rightIn.(type) {
+	case int:
+		return c.Plus(K(right))
 	case float64:
 		return c.Plus(K(right))
 	case K:
@@ -114,10 +117,14 @@ func (c K) Plus(rightIn interface{}) Expression {
 		return c.Plus(VecDenseToKVector(right))
 	case *mat.VecDense:
 		return c.Plus(VecDenseToKVector(*right))
-	case KVector:
-		return right.Plus(c)
-	case PolynomialVector:
-		return right.Plus(c)
+	case KVector, VariableVector, MonomialVector, PolynomialVector:
+		// Convert to VectorExpression
+		ve, _ := ToVectorExpression(right)
+		return ve.Plus(c)
+	case KMatrix, VariableMatrix, MonomialMatrix, PolynomialMatrix:
+		// Convert to MatrixExpression
+		me, _ := ToMatrixExpression(right)
+		return me.Plus(c)
 	}
 
 	// Default response is a panic
@@ -129,6 +136,45 @@ func (c K) Plus(rightIn interface{}) Expression {
 	)
 }
 
+/*
+Minus
+Description:
+
+	This function subtracts the current expression from another and returns the resulting expression.
+*/
+func (c K) Minus(rightIn interface{}) Expression {
+	// Input Processing
+	if IsExpression(rightIn) {
+		rightAsE, _ := ToExpression(rightIn)
+		err := rightAsE.Check()
+		if err != nil {
+			panic(fmt.Errorf("error in second argument to %v.Minus: %v", c, err))
+		}
+
+		//err = smErrors.CheckDimensionsInSubtraction(c, rightAsE)
+		//if err != nil {
+		//	panic(err)
+		//}
+
+		// Use Minus function
+		return Minus(c, rightAsE)
+	}
+
+	// Switching based on input type
+	switch right := rightIn.(type) {
+	case float64:
+		return c.Minus(K(right))
+	}
+
+	// Default response is a panic
+	panic(
+		smErrors.UnsupportedInputError{
+			FunctionName: "K.Minus",
+			Input:        rightIn,
+		},
+	)
+}
+
 // LessEq returns a less than or equal to (<=) constraint between the
 // current expression and another
 func (c K) LessEq(rightIn interface{}) Constraint {
@@ -172,14 +218,10 @@ func (c K) Comparison(rhsIn interface{}, sense ConstrSense) Constraint {
 	case float64:
 		// Use the version of Comparison for K
 		return c.Comparison(K(right), sense)
-	case K:
-		return ScalarConstraint{c, right, sense}
-	case Variable:
-		return ScalarConstraint{c, right, sense}
-	case Monomial:
-		return ScalarConstraint{c, right, sense}
-	case Polynomial:
-		return ScalarConstraint{c, right, sense}
+	case K, Variable, Monomial, Polynomial:
+		// Cast right to scalar expression
+		se, _ := ToScalarExpression(right)
+		return ScalarConstraint{c, se, sense}
 	case mat.VecDense:
 		// Convert to KVector
 		return c.Comparison(VecDenseToKVector(right), sense)
@@ -235,18 +277,26 @@ func (c K) Multiply(term1 interface{}) Expression {
 
 	// Input Processing
 	if IsExpression(term1) {
-		// Check dimensions
+		// Cast to expression
 		term1AsE, _ := ToExpression(term1)
-		err := smErrors.CheckDimensionsInMultiplication(c, term1AsE)
+		err := term1AsE.Check()
 		if err != nil {
 			panic(err)
 		}
+
+		//// Check dimensions (not necessary for scalar K)
+		//err := smErrors.CheckDimensionsInMultiplication(c, term1AsE)
+		//if err != nil {
+		//	panic(err)
+		//}
 	}
 
 	// Algorithm
 	switch right := term1.(type) {
 	case float64:
 		return c.Multiply(K(right))
+	case int:
+		return c.Multiply(K(right))
 	case K:
 		return c * right
 	case Variable:

Diff for: symbolic/constant_matrix.go

@@ -166,6 +166,57 @@ func (km KMatrix) Plus(e interface{}) Expression {
 	)
 }
 
+/*
+Minus
+Description:
+
+	Subtraction of the constant matrix with another expression.
+*/
+func (km KMatrix) Minus(e interface{}) Expression {
+	// Input Processing
+	err := km.Check()
+	if err != nil {
+		panic(err)
+	}
+
+	if IsExpression(e) {
+		rightAsE, _ := ToExpression(e)
+
+		// Check expression
+		err = rightAsE.Check()
+		if err != nil {
+			panic(err)
+		}
+
+		// Check Dimensions
+		err = smErrors.CheckDimensionsInSubtraction(km, rightAsE)
+		if err != nil {
+			panic(err)
+		}
+
+		// Use Expression method
+		return Minus(km, rightAsE)
+	}
+
+	// Algorithm
+	switch right := e.(type) {
+	case float64:
+		return km.Minus(K(right)) // Reuse K case
+	case mat.Dense:
+		return km.Minus(DenseToKMatrix(right)) // Reuse KMatrix case
+	case *mat.Dense:
+		return km.Minus(*right) // Reuse mat.Dense case
+	}
+
+	// If we reach this point, the input is not recognized
+	panic(
+		smErrors.UnsupportedInputError{
+			FunctionName: "KMatrix.Minus",
+			Input:        e,
+		},
+	)
+}
+
 /*
 Multiply
 Description:
@@ -612,3 +663,13 @@ func (km KMatrix) ToPolynomialMatrix() PolynomialMatrix {
 	// Return
 	return pm
 }
+
+/*
+Degree
+Description:
+
+	The degree of a constant matrix is always 0.
+*/
+func (km KMatrix) Degree() int {
+	return 0
+}

Diff for: symbolic/constant_vector.go

@@ -138,6 +138,13 @@ func (kv KVector) Plus(rightIn interface{}) Expression {
 	case K:
 		// Return Addition
 		return kv.Plus(float64(right))
+	case Variable:
+		// Create a new polynomial vector
+		var pvOut PolynomialVector
+		for _, element := range kv {
+			pvOut = append(pvOut, element.Plus(right).(Polynomial))
+		}
+		return pvOut
 
 	case *mat.VecDense:
 		return kv.Plus(VecDenseToKVector(*right)) // Convert to KVector
@@ -166,6 +173,53 @@ func (kv KVector) Plus(rightIn interface{}) Expression {
 	}
 }
 
+/*
+Minus
+Description:
+
+	Subtracts the current expression from another and returns the resulting expression
+*/
+func (kv KVector) Minus(e interface{}) Expression {
+	// Input Processing
+	err := kv.Check()
+	if err != nil {
+		panic(err)
+	}
+
+	if IsExpression(e) {
+		// Check right
+		eAsE, _ := ToExpression(e)
+		err = eAsE.Check()
+		if err != nil {
+			panic(err)
+		}
+
+		// Check dimensions
+		err = smErrors.CheckDimensionsInSubtraction(kv, eAsE)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	// Algorithm
+	switch right := e.(type) {
+	case float64:
+		return kv.Minus(K(right)) // Reuse K case
+	case mat.VecDense:
+		return kv.Minus(VecDenseToKVector(right)) // Convert to KVector
+	case *mat.VecDense:
+		return kv.Minus(VecDenseToKVector(*right)) // Convert to KVector
+	}
+
+	// Default response is a panic
+	panic(
+		smErrors.UnsupportedInputError{
+			FunctionName: "KVector.Minus",
+			Input:        e,
+		},
+	)
+}
+
 /*
 LessEq
 Description:
@@ -527,3 +581,13 @@ Description:
 func (kv KVector) ToPolynomialVector() PolynomialVector {
 	return kv.ToMonomialVector().ToPolynomialVector()
 }
+
+/*
+Degree
+Description:
+
+	The degree of a constant matrix is always 0.
+*/
+func (kv KVector) Degree() int {
+	return 0
+}

Diff for: symbolic/expression.go

@@ -21,6 +21,10 @@ type Expression interface {
 	// expression
 	Plus(rightIn interface{}) Expression
 
+	// Minus subtracts an expression from the current one and returns the resulting
+	// expression
+	Minus(rightIn interface{}) Expression
+
 	// Multiply multiplies the current expression to another and returns the
 	// resulting expression
 	Multiply(rightIn interface{}) Expression
@@ -108,3 +112,55 @@ func ToExpression(e interface{}) (Expression, error) {
 		},
 	)
 }
+
+/*
+Minus
+Description:
+
+	subtracts the current expression from another and returns the resulting expression
+*/
+func Minus(left, right Expression) Expression {
+	return left.Plus(
+		right.Multiply(-1.0),
+	)
+}
+
+/*
+IsLinear
+Description:
+
+	Determines whether an input object is a
+	valid linear expression.
+	In math, this means that the polynomial like expression
+	has a degree less than or equal to 1.
+*/
+func IsLinear(e Expression) bool {
+	// Input Processing
+	if !IsPolynomialLike(e) {
+		return false // Not a polynomial like expression, so it can't be linear
+	}
+
+	eAsPL, _ := ToPolynomialLike(e)
+
+	return eAsPL.Degree() <= 1
+}
+
+/*
+IsQuadratic
+Description:
+
+	Determines whether or not an input object is a
+	valid Quadratic Expression.
+	In math, this means that the polynomial like expression
+	has a degree less than or equal to 2.
+*/
+func IsQuadratic(e Expression) bool {
+	// Input Processing
+	if !IsPolynomialLike(e) {
+		return false // Not a polynomial like expression, so it can't be linear
+	}
+
+	eAsPL, _ := ToPolynomialLike(e)
+
+	return eAsPL.Degree() <= 2
+}