Added a new error for when an optimization problem is not linear

Author: kwesiRutledge

causeOfProblemNonlinearity/causes.go

@@ -0,0 +1,9 @@
+package causeOfProblemNonlinearity
+
+type Cause string
+
+const (
+	Objective      Cause = "Objective"
+	Constraint           = "Constraint"
+	NotWellDefined       = "NotWellDefined"
+)

mpiErrors/not_linear.go

@@ -0,0 +1,29 @@
+package mpiErrors
+
+import (
+	"fmt"
+
+	"github.com/MatProGo-dev/MatProInterface.go/causeOfProblemNonlinearity"
+)
+
+type ProblemNotLinearError struct {
+	ProblemName     string
+	Cause           causeOfProblemNonlinearity.Cause
+	ConstraintIndex int // Index of the constraint that is not linear, if applicable
+}
+
+func (e ProblemNotLinearError) Error() string {
+	preamble := "The problem " + e.ProblemName + " is not linear"
+	switch e.Cause {
+	case causeOfProblemNonlinearity.Objective:
+		preamble += "; the objective is not linear"
+	case causeOfProblemNonlinearity.Constraint:
+		preamble += fmt.Sprintf("; constraint #%v is not linear", e.ConstraintIndex)
+	case causeOfProblemNonlinearity.NotWellDefined:
+		preamble += "; the problem is not well defined"
+	default:
+		preamble += "; the cause of the problem is not recognized (create an issue on GitHub if you think this is a bug!)"
+	}
+	// Return the error message
+	return preamble
+}

problem/optimization_problem.go

@@ -3,6 +3,7 @@ package problem
 import (
 	"fmt"
 
+	"github.com/MatProGo-dev/MatProInterface.go/causeOfProblemNonlinearity"
 	"github.com/MatProGo-dev/MatProInterface.go/mpiErrors"
 	"github.com/MatProGo-dev/MatProInterface.go/optim"
 	getKVector "github.com/MatProGo-dev/SymbolicMath.go/get/KVector"
@@ -320,25 +321,28 @@ Description:
 	2. All constraints are linear (i.e., an affine combination of variables in an inequality or equality).
 */
 func (op *OptimizationProblem) IsLinear() bool {
-	// Input Processing
-	// Verify that the problem is well-formed
-	err := op.Check()
+	// Run the check method
+	err := op.CheckIfLinear()
 	if err != nil {
-		panic(fmt.Errorf("the optimization problem is not well-formed: %v", err))
-	}
+		// If the check method returns a NotWellDefinedError, then the problem is not well defined
+		// and we should panic.
+		notWellDefinedError := mpiErrors.ProblemNotLinearError{
+			ProblemName:     op.Name,
+			Cause:           causeOfProblemNonlinearity.NotWellDefined,
+			ConstraintIndex: -1,
+		}
+		if err.Error() == notWellDefinedError.Error() {
+			panic(
+				fmt.Errorf(
+					"the optimization problem is not well defined; %v",
+					op.Check(),
+				))
+		}
 
-	// Check Objective
-	if !op.Objective.IsLinear() {
+		// If the check returns any other error, then the problem is not linear
 		return false
 	}
 
-	// Check Constraints
-	for _, constraint := range op.Constraints {
-		if !constraint.IsLinear() {
-			return false
-		}
-	}
-
 	// All Checks Passed!
 	return true
 }
@@ -645,12 +649,12 @@ func (problemIn *OptimizationProblem) ToLPStandardForm1() (*OptimizationProblem,
 	// Input Processing
 	err := problemIn.Check()
 	if err != nil {
-		panic(fmt.Errorf("the optimization problem is not well-formed: %v", err))
+		return nil, nil, fmt.Errorf("the optimization problem is not well-formed: %v", err)
 	}
 
 	// Check if the problem is linear
 	if !problemIn.IsLinear() {
-		panic(fmt.Errorf("the optimization problem is not linear: %v", err))
+		return nil, nil, problemIn.CheckIfLinear()
 	}
 
 	// Setup
@@ -810,3 +814,46 @@ func (problemIn *OptimizationProblem) ToLPStandardForm1() (*OptimizationProblem,
 	// Return the new problem and the slack variables
 	return problemInStandardForm, slackVariables, nil
 }
+
+/*
+CheckIfLinear
+Description:
+
+	Checks the current optimization problem to see if it is linear.
+	Returns an error if the problem is not linear.
+*/
+func (op *OptimizationProblem) CheckIfLinear() error {
+	// Input Processing
+	// Verify that the problem is well-formed
+	err := op.Check()
+	if err != nil {
+		return mpiErrors.ProblemNotLinearError{
+			ProblemName:     op.Name,
+			Cause:           causeOfProblemNonlinearity.NotWellDefined,
+			ConstraintIndex: -1,
+		}
+	}
+
+	// Check Objective
+	if !op.Objective.IsLinear() {
+		return mpiErrors.ProblemNotLinearError{
+			ProblemName:     op.Name,
+			Cause:           causeOfProblemNonlinearity.Objective,
+			ConstraintIndex: -2,
+		}
+	}
+
+	// Check Constraints
+	for ii, constraint := range op.Constraints {
+		if !constraint.IsLinear() {
+			return mpiErrors.ProblemNotLinearError{
+				ProblemName:     op.Name,
+				Cause:           causeOfProblemNonlinearity.Constraint,
+				ConstraintIndex: ii,
+			}
+		}
+	}
+
+	// All Checks Passed!
+	return nil
+}

testing/problem/optimization_problem_test.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/MatProGo-dev/MatProInterface.go/causeOfProblemNonlinearity"
 	"github.com/MatProGo-dev/MatProInterface.go/mpiErrors"
 	"github.com/MatProGo-dev/MatProInterface.go/optim"
 	"github.com/MatProGo-dev/MatProInterface.go/problem"
@@ -2206,3 +2207,95 @@ func TestOptimizationProblem_ToLPStandardForm3(t *testing.T) {
 	}
 
 }
+
+/*
+TestOptimizationProblem_ToLPStandardForm4
+Description:
+
+	This test verifies that the ToLPStandardForm function throws an error
+	when called on a problem that is not linear.
+	In this case, we will define a problem with a quadratic objective function.
+	The problem will have:
+	- a quadratic objective
+	- 2 variables,
+	- and a single linear inequality constraint.
+*/
+func TestOptimizationProblem_ToLPStandardForm4(t *testing.T) {
+	// Constants
+	p1 := problem.NewProblem("TestOptimizationProblem_ToLPStandardForm4")
+	v1 := p1.AddVariable()
+	p1.AddVariable()
+	c1 := v1.LessEq(1.0)
+
+	p1.Constraints = append(p1.Constraints, c1)
+
+	// Create a quadratic objective
+	p1.Objective = *problem.NewObjective(
+		v1.Multiply(v1),
+		problem.SenseMaximize,
+	)
+
+	// Algorithm
+	_, _, err := p1.ToLPStandardForm1()
+	if err == nil {
+		t.Errorf("expected an error; received nil")
+	} else {
+		expectedError := mpiErrors.ProblemNotLinearError{
+			ProblemName:     p1.Name,
+			Cause:           causeOfProblemNonlinearity.Objective,
+			ConstraintIndex: -2,
+		}
+		if !strings.Contains(
+			err.Error(),
+			expectedError.Error(),
+		) {
+			t.Errorf("unexpected error: %v", err)
+		}
+	}
+}
+
+/*
+TestOptimizationProblem_ToLPStandardForm5
+Description:
+
+	This test verifies that the ToLPStandardForm function throws an error
+	when called on a problem that is not linear.
+	In this case, we will define a problem with a quadratic constraint.
+	The problem will have:
+	- a constant objective
+	- 2 variables,
+	- and a single quadratic inequality constraint.
+*/
+func TestOptimizationProblem_ToLPStandardForm5(t *testing.T) {
+	// Constants
+	p1 := problem.NewProblem("TestOptimizationProblem_ToLPStandardForm5")
+	v1 := p1.AddVariable()
+	p1.AddVariable()
+	c1 := v1.Multiply(v1).LessEq(1.0)
+
+	p1.Constraints = append(p1.Constraints, c1)
+
+	// Create good objective
+	p1.Objective = *problem.NewObjective(
+		symbolic.K(3.14),
+		problem.SenseMaximize,
+	)
+
+	// Algorithm
+	_, _, err := p1.ToLPStandardForm1()
+	if err == nil {
+		t.Errorf("expected an error; received nil")
+	} else {
+		expectedError := mpiErrors.ProblemNotLinearError{
+			ProblemName:     p1.Name,
+			Cause:           causeOfProblemNonlinearity.Constraint,
+			ConstraintIndex: 0,
+		}
+		if !strings.Contains(
+			err.Error(),
+			expectedError.Error(),
+		) {
+			t.Errorf("unexpected error: %v", err)
+		}
+	}
+}