Copied More Files from MatProInterface.go; Much more debugging needed

Author: Kwesi Rutledge

symbolic/constant.go

@@ -70,10 +70,6 @@ func (c K) Plus(rightIn interface{}, errors ...error) (Expression, error) {
 		return K(c.Constant() + right.Constant()), nil
 	case Variable:
 		return right.Plus(c)
-	case ScalarLinearExpr:
-		return right.Plus(c)
-	case ScalarQuadraticExpression:
-		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", right, right)
 	}
@@ -156,19 +152,6 @@ func (c K) Multiply(term1 interface{}, errors ...error) (Expression, error) {
 		term1AsSLE := right.ToScalarLinearExpression()
 
 		return c.Multiply(term1AsSLE)
-	case ScalarLinearExpr:
-		// Scale all vectors and constants
-		sleOut := right.Copy()
-		sleOut.L.ScaleVec(float64(c), &sleOut.L)
-		sleOut.C = right.C * float64(c)
-
-		return sleOut, nil
-	case ScalarQuadraticExpression:
-		// Scale all matrices and constants
-		var sqeOut ScalarQuadraticExpression
-		sqeOut.Q.Scale(float64(c), &right.Q)
-		sqeOut.L.ScaleVec(float64(c), &right.L)
-		sqeOut.C = float64(c) * right.C
 
 		return sqeOut, nil
 	case KVector:
@@ -243,3 +226,17 @@ func (c K) Check() error {
 func (c K) Transpose() Expression {
 	return c
 }
+
+/*
+ToMonomial
+Description:
+
+	Converts the constant into a monomial.
+*/
+func (c K) ToMonomial() Monomial {
+	return Monomial{
+		Coefficient:     float64(c),
+		VariableFactors: []Variable{},
+		Degrees:         []int{},
+	}
+}

symbolic/errors.go

@@ -65,3 +65,57 @@ func (uie UnexpectedInputError) Error() string {
 		uie.InputInQuestion,
 	)
 }
+
+/*
+CheckErrors
+Description:
+*/
+func CheckErrors(extras []error) error {
+	// Constants
+
+	// Check all of the extras to see if one of them contains an error
+	switch {
+	case len(extras) == 1:
+		return extras[0]
+
+	case len(extras) > 1:
+		return fmt.Errorf(
+			"did not expect to receive more than one element in 'extras' input; received %v",
+			len(extras),
+		)
+	}
+
+	// If extras has length 0, then return nil
+	return nil
+}
+
+func CheckDimensionsInMultiplication(left, right Expression) error {
+	// Check that the # of columns in left
+	// matches the # of rows in right
+	if left.Dims()[1] != right.Dims()[0] {
+		return DimensionError{
+			Operation: "Multiply",
+			Arg1:      left,
+			Arg2:      right,
+		}
+	}
+	// 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
+}

symbolic/expression.go

@@ -1,5 +1,7 @@
 package symbolic
 
+import "fmt"
+
 /*
 Expression
 Description:
@@ -43,6 +45,33 @@ type Expression interface {
 	Comparison(rightIn interface{}, sense ConstrSense, errors ...error) (Constraint, error)
 }
 
+/*
+NumVariables
+Description:
+
+	The number of distinct variables.
+*/
 func NumVariables(e Expression) int {
 	return len(e.Variables())
 }
+
+/*
+IsExpression
+Description:
+
+	Tests whether or not the input variable is one of the expression types.
+*/
+func IsExpression(e interface{}) bool {
+	return IsScalarExpression(e) || IsVectorExpression(e)
+}
+
+func ToExpression(e interface{}) (Expression, error) {
+	switch {
+	case IsScalarExpression(e):
+		return ToScalarExpression(e)
+	case IsVectorExpression(e):
+		return ToVectorExpression(e)
+	default:
+		return K(Infinity), fmt.Errorf("the input expression is not recognized as a scalar or vector expression.")
+	}
+}

symbolic/monomial.go

@@ -0,0 +1,16 @@
+package symbolic
+
+/*
+monomial.go
+Description:
+	This file defines the function associated with the Monomial object.
+*/
+
+/*
+Type Definition
+*/
+type Monomial struct {
+	Coefficient     float64
+	Degrees         []int
+	VariableFactors []Variable
+}

symbolic/polynomial.go

@@ -0,0 +1,14 @@
+package symbolic
+
+/*
+polynomial.go
+Description:
+	This file defines the function associated with the Polynomial object.
+*/
+
+/*
+Type Definition
+*/
+type Polynomial struct {
+	Monomials []Monomial
+}

symbolic/scalar_expression.go

@@ -12,9 +12,6 @@ type ScalarExpression interface {
 	// Variables returns the variables included in the scalar expression
 	Variables() []Variable
 
-	// NumVars returns the number of variables in the expression
-	NumVars() int
-
 	// Vars returns a slice of the Var ids in the expression
 	IDs() []uint64
 
@@ -84,10 +81,6 @@ func IsScalarExpression(e interface{}) bool {
 		return true
 	case Variable:
 		return true
-	case ScalarLinearExpr:
-		return true
-	case ScalarQuadraticExpression:
-		return true
 	default:
 		return false
 

symbolic/variable.go

@@ -11,7 +11,7 @@ type Variable struct {
 	ID    uint64
 	Lower float64
 	Upper float64
-	Vtype VarType
+	Type  VarType
 }
 
 /*
@@ -214,7 +214,7 @@ func (v *Variable) Upper() float64 {
 
 // Type returns the type of variable (continuous, binary, integer, etc)
 func (v *Variable) Type() VarType {
-	return v.Vtype
+	return v.Type
 }
 */
 
@@ -302,77 +302,11 @@ func (v Variable) Multiply(val interface{}, errors ...error) (Expression, error)
 		}
 		return sqeOut, nil
 
-	case ScalarLinearExpr:
-		// Algorithm
-		sqeOut := ScalarQuadraticExpression{
-			X: VarVector{
-				UniqueVars(append(e.X.Elements, v)),
-			},
-			C: 0.0,
-		}
-		sqeOut.Q = ZerosMatrix(sqeOut.X.Len(), sqeOut.X.Len())
-		sqeOut.L = ZerosVector(sqeOut.X.Len())
-
-		// Update Q
-		vIndex, _ := FindInSlice(v, e.X.Elements)           // err should be nil
-		vIndexInSQE, _ := FindInSlice(v, sqeOut.X.Elements) // err should be nil
-		for xIndex := 0; xIndex < e.L.Len(); xIndex++ {
-			// Check to make sure index is not the vIndex
-			if vIndex == xIndex {
-				// If v is in the original slice (i.e., we now need to represent v^2)
-
-				sqeOut.Q.Set(vIndexInSQE, vIndexInSQE, e.L.AtVec(vIndex))
-			} else {
-				// If xIndex is not for v, then create off-diagonal elements
-				xIndexInSQE, _ := FindInSlice(e.X.AtVec(xIndex), sqeOut.X.Elements)
-
-				// Create a pair of off-diagonal elements
-				sqeOut.Q.Set(vIndexInSQE, xIndexInSQE, e.L.AtVec(xIndex)*0.5)
-				sqeOut.Q.Set(xIndexInSQE, vIndexInSQE, e.L.AtVec(xIndex)*0.5)
-
-			}
-		}
-
-		// Update L
-		sqeOut.L.SetVec(vIndexInSQE, e.C)
-
-		return sqeOut, nil
-
-	case ScalarQuadraticExpression:
-		// Return error
-		return ScalarQuadraticExpression{}, fmt.Errorf("Can not multiply Variable with ScalarQuadraticExpression. MatProInterface can not represent polynomials higher than degree 2.")
-
-	case VectorLinearExpressionTranspose:
-		return ScalarQuadraticExpression{}, fmt.Errorf(
-			"cannot currently multiply a variable with a vector to create a quadratic expression; file an issue if you are interested in seeing a feature like this.",
-		)
-
 	default:
 		return v, fmt.Errorf("Unexpected input to v.Multiply(): %T", val)
 	}
 }
 
-/*
-ToScalarLinearExpression
-Description:
-
-	Converting the variable into a scalar linear Expression.
-*/
-func (v Variable) ToScalarLinearExpression() ScalarLinearExpr {
-	// Constants
-
-	// Create components
-	vars := []Variable{v}
-	coeffs := []float64{v.Coeffs()[0]}
-
-	// Create sle
-	return ScalarLinearExpr{
-		X: VarVector{vars},
-		L: *mat.NewVecDense(1, coeffs),
-		C: 0,
-	}
-}
-
 /*
 Dims
 Description:
@@ -439,7 +373,7 @@ func NewContinuousVariable(envs ...Environment) Variable {
 		ID:    uint64(nextIdx),
 		Lower: float64(-Infinity),
 		Upper: float64(+Infinity),
-		Vtype: Continuous,
+		Type:  Continuous,
 	}
 
 }
@@ -469,7 +403,7 @@ func NewBinaryVariable(envs ...Environment) Variable {
 		ID:    uint64(nextIdx),
 		Lower: 0.0,
 		Upper: 1.0,
-		Vtype: Binary,
+		Type:  Binary,
 	}
 
 }

symbolic/vector_expression.go

@@ -28,8 +28,8 @@ type VectorExpression interface {
 	// IDs returns a slice of the Var ids in the expression
 	IDs() []uint64
 
-	// Coeffs returns a slice of the coefficients in the expression
-	LinearCoeff() mat.Dense
+	//// Coeffs returns a slice of the coefficients in the expression
+	//LinearCoeff() mat.Dense
 
 	// Constant returns the constant additive value in the expression
 	Constant() mat.VecDense
@@ -72,17 +72,17 @@ type VectorExpression interface {
 	Dims() []int
 }
 
-/*
-NewVectorExpression
-Description:
-
-	NewExpr returns a new expression with a single additive constant value, c,
-	and no variables. Creating an expression like sum := NewVectorExpr(0) is useful
-	for creating new empty expressions that you can perform operatotions on later
-*/
-func NewVectorExpression(c mat.VecDense) VectorLinearExpr {
-	return VectorLinearExpr{C: c}
-}
+///*
+//NewVectorExpression
+//Description:
+//
+//	NewExpr returns a new expression with a single additive constant value, c,
+//	and no variables. Creating an expression like sum := NewVectorExpr(0) is useful
+//	for creating new empty expressions that you can perform operatotions on later
+//*/
+//func NewVectorExpression(c mat.VecDense) VectorLinearExpr {
+//	return VectorLinearExpr{C: c}
+//}
 
 //func (e VectorExpression) getVarsPtr() *uint64 {
 //
@@ -112,18 +112,6 @@ func IsVectorExpression(e interface{}) bool {
 	switch e.(type) {
 	case mat.VecDense:
 		return true
-	case KVector:
-		return true
-	case KVectorTranspose:
-		return true
-	case VarVector:
-		return true
-	case VarVectorTranspose:
-		return true
-	case VectorLinearExpr:
-		return true
-	case VectorLinearExpressionTranspose:
-		return true
 	default:
 		return false