Added More Tests for OptimizationProblem.From which required standardizing a Check() method for all constraints and adding Check() methods for a few expressions in the optim package

Author: kwesiRutledge

optim/constr_sense.go

@@ -32,3 +32,21 @@ func (cs ConstrSense) ToSymbolic() symbolic.ConstrSense {
 	}
 	return '1'
 }
+
+/*
+String
+Description:
+
+	Returns the string representation of the constraint sense.
+*/
+func (cs ConstrSense) String() string {
+	switch cs {
+	case SenseEqual:
+		return "=="
+	case SenseLessThanEqual:
+		return "<="
+	case SenseGreaterThanEqual:
+		return ">="
+	}
+	return "UNRECOGNIZED ConstrSense"
+}

optim/scalar_constraint.go

@@ -130,7 +130,17 @@ func (sc ScalarConstraint) Check() error {
 		return fmt.Errorf("the constraint sense is not recognized.")
 	}
 
-	// Check left and right hand sides?
+	// Check left and right hand sides
+	err := sc.LeftHandSide.Check()
+	if err != nil {
+		return fmt.Errorf("left hand side of the constraint is not valid: %v", err)
+	}
+
+	// Check right hand side
+	err = sc.RightHandSide.Check()
+	if err != nil {
+		return fmt.Errorf("right hand side of the constraint is not valid: %v", err)
+	}
 
 	// Return
 	return nil

optim/scalar_expression.go

@@ -63,6 +63,9 @@ type ScalarExpression interface {
 	//ToSymbolic Returns the symbolic version of the scalar expression
 	// (i.e., the expression when declared using the symbolic math toolbox).
 	ToSymbolic() (symbolic.Expression, error)
+
+	// Check, checks the expression for any errors
+	Check() error
 }
 
 // NewExpr returns a new expression with a single additive constant value, c,

optim/var_vector.go

@@ -294,9 +294,6 @@ Description:
 	input rhs as the right hand side if it is valid.
 */
 func (vv VarVector) Eq(rightIn interface{}, errors ...error) (Constraint, error) {
-	// Constants
-
-	// Algorithm
 	return vv.Comparison(rightIn, SenseEqual, errors...)
 
 }
@@ -373,7 +370,11 @@ func (vv VarVector) Comparison(rhs interface{}, sense ConstrSense, errors ...err
 			)
 
 	default:
-		return VectorConstraint{}, fmt.Errorf("The Eq() method for VarVector is not implemented yet for type %T!", rhs)
+		return VectorConstraint{}, fmt.Errorf(
+			"The VarVector.Comparison (%v) method is not implemented yet for type %T!",
+			sense,
+			rhs,
+		)
 	}
 }
 

optim/vector_constant.go

@@ -23,6 +23,17 @@ KVector
 */
 type KVector mat.VecDense // Inherit all methods from mat.VecDense
 
+/*
+Check
+Description:
+
+	This method checks for errors in the KVector type.
+	There should never be any.
+*/
+func (kv KVector) Check() error {
+	return nil
+}
+
 /*
 Len
 

optim/vector_constant_transpose.go

@@ -23,6 +23,17 @@ KVectorTranspose
 */
 type KVectorTranspose mat.VecDense // Inherit all methods from mat.VecDense
 
+/*
+Check
+Description:
+
+	This method checks for errors in the KVectorTranspose type.
+	There should never be any.
+*/
+func (kvt KVectorTranspose) Check() error {
+	return nil
+}
+
 /*
 Len
 

optim/vector_constraint.go

@@ -60,6 +60,17 @@ func (vc VectorConstraint) Check() error {
 		)
 	}
 
+	// Check that the left and right hand sides are well-defined
+	err := vc.LeftHandSide.Check()
+	if err != nil {
+		return fmt.Errorf("left hand side of the constraint is not valid: %v", err)
+	}
+
+	err = vc.RightHandSide.Check()
+	if err != nil {
+		return fmt.Errorf("right hand side of the constraint is not valid: %v", err)
+	}
+
 	// All Checks Passed!
 	return nil
 }

optim/vector_expression.go

@@ -75,6 +75,10 @@ type VectorExpression interface {
 	//ToSymbolic
 	// Converts the expression to a symbolic expression (in SymbolicMath.go)
 	ToSymbolic() (symbolic.Expression, error)
+
+	//Check
+	// Checks the expression for any errors
+	Check() error
 }
 
 /*

problem/optimization_problem.go

@@ -177,16 +177,10 @@ func ToSymbolicConstraint(inputConstraint optim.Constraint) (symbolic.Constraint
 	}
 
 	// Convert LHS to symbolic expression
-	lhs, err := inputConstraint.Left().ToSymbolic()
-	if err != nil {
-		return symbolic.ScalarConstraint{}, err
-	}
+	lhs, _ := inputConstraint.Left().ToSymbolic()
 
 	// Convert RHS to symbolic expression
-	rhs, err := inputConstraint.Right().ToSymbolic()
-	if err != nil {
-		return symbolic.ScalarConstraint{}, err
-	}
+	rhs, _ := inputConstraint.Right().ToSymbolic()
 
 	// Get Sense
 	sense := inputConstraint.ConstrSense().ToSymbolic()