Merge pull request #2 from MatProGo-dev/kr/feature/gonum-bug1

Adding a bit more documentation + clarifying some interfaces

Author: kwesiRutledge

README.md

@@ -1,2 +1,82 @@
 # simplex
 A small library used to demonstrate the concepts of the Simplex algorithm in convex optimization.
+
+# Installation
+
+You can add this module to your package using:
+```bash
+go get github.com/MatProGo-dev/simplex
+```
+
+# Usage
+
+```
+package main
+
+import (
+	"github.com/MatProGo-dev/MatProInterface.go/problem"
+	getKVector "github.com/MatProGo-dev/SymbolicMath.go/get/KVector"
+	"github.com/MatProGo-dev/SymbolicMath.go/symbolic"
+	"github.com/MatProGo-dev/simplex/simplexSolver"
+)
+
+func BuildOptimizationProblem() problem.OptimizationProblem {
+	// setup
+	varCount := 2
+	out := problem.NewProblem("Box LP Problem")
+
+	// Create the variables
+	x := out.AddVariableVector(varCount)
+
+	// Create the objective
+	c := getKVector.From(
+		[]float64{1, 2},
+	)
+	out.SetObjective(
+		c.Transpose().Multiply(x),
+		problem.SenseMinimize,
+	)
+
+	// Create the constraints
+	// - x >= 0
+	out.Constraints = append(
+		out.Constraints,
+		x.GreaterEq(symbolic.ZerosVector(varCount)),
+	)
+
+	// - x <= 1
+	out.Constraints = append(
+		out.Constraints,
+		x.LessEq(symbolic.OnesVector(varCount)),
+	)
+
+	return *out
+}
+
+func main() {
+	// This is just a placeholder to make the package "main" valid.
+	trickyProblem := BuildOptimizationProblem()
+
+	// Use solver to solve the problem
+	solver := simplexSolver.New("Simplex Solver Example")
+	solver.IterationLimit = 100
+
+	// Solve the problem
+	solution, err := solver.Solve(trickyProblem)
+	if err != nil {
+		panic(err)
+	}
+
+	// Print the solution
+	solutionMessage, _ := solution.Status.ToMessage()
+	println("Solution Status: ", solutionMessage)
+	println("Objective Value: ", solution.Objective)
+	println("Number of Iterations: ", solution.Iterations)
+	println("Variable Values: ")
+	for varName, varValue := range solution.VariableValues {
+		println("  ", varName, ": ", varValue)
+	}
+}
+```
+
+See the examples directory for more example use cases for the library.

algorithms/algorithm_interface.go

@@ -2,9 +2,10 @@ package algorithms
 
 import (
 	"github.com/MatProGo-dev/MatProInterface.go/problem"
+	simplex_solution "github.com/MatProGo-dev/simplex/solution"
 )
 
 type AlgorithmInterface interface {
 	// Solves the provided optimization problem.
-	Solve(prob problem.OptimizationProblem) (problem.Solution, error)
+	Solve(prob problem.OptimizationProblem) (simplex_solution.SimplexSolution, error)
 }

algorithms/stanford/stanford.go

@@ -4,7 +4,9 @@ import (
 	"fmt"
 
 	"github.com/MatProGo-dev/MatProInterface.go/problem"
+	solution_status "github.com/MatProGo-dev/MatProInterface.go/solution/status"
 	"github.com/MatProGo-dev/SymbolicMath.go/symbolic"
+	simplex_solution "github.com/MatProGo-dev/simplex/solution"
 	"github.com/MatProGo-dev/simplex/utils"
 	"gonum.org/v1/gonum/mat"
 )
@@ -178,11 +180,11 @@ Description:
 	- The values of the basic variables
 	- The values of the non-basic variables
 */
-func (algo *StanfordAlgorithm) ComputeSolutionFromState(state StanfordAlgorithmState) (problem.Solution, error) {
+func (algo *StanfordAlgorithm) ComputeSolutionFromState(state StanfordAlgorithmState) (simplex_solution.SimplexSolution, error) {
 	// Setup
 	fmt.Printf("Computing solution from state...\n")
-	solution := problem.Solution{
-		Status: problem.OptimizationStatus_OPTIMAL,
+	solution := simplex_solution.SimplexSolution{
+		Status: solution_status.OPTIMAL,
 	}
 
 	// Compute the feasible solution of the basic variables
@@ -192,26 +194,25 @@ func (algo *StanfordAlgorithm) ComputeSolutionFromState(state StanfordAlgorithmS
 	}
 
 	// Compute the value of the objective function
-	objValue, err := algo.ComputeObjectiveFunctionValueWithFeasibleBasicSolution(state, xBasic)
+	_, err = algo.ComputeObjectiveFunctionValueWithFeasibleBasicSolution(state, xBasic)
 	if err != nil {
 		return solution, fmt.Errorf("StanfordAlgorithm: Failed to compute objective function value (%v)", err)
 	}
-	solution.Objective = objValue
 
 	// Set the values of the basic variables
 	for ii, bv := range state.BasicVariables {
-		solution.Values[bv.ID] = xBasic.AtVec(ii)
+		solution.VariableValues[bv.ID] = xBasic.AtVec(ii)
 	}
 
 	// Set the values of the non-basic variables
 	for jj, nv := range state.GetNonBasicVariables() {
-		solution.Values[nv.ID] = state.NonBasicValues.AtVec(jj)
+		solution.VariableValues[nv.ID] = state.NonBasicValues.AtVec(jj)
 	}
 
 	return solution, nil
 }
 
-func (algo *StanfordAlgorithm) Solve(initialState StanfordAlgorithmState) (problem.Solution, error) {
+func (algo *StanfordAlgorithm) Solve(initialState StanfordAlgorithmState) (simplex_solution.SimplexSolution, error) {
 	// Setup
 	var stateII StanfordAlgorithmState = initialState
 
@@ -221,7 +222,7 @@ func (algo *StanfordAlgorithm) Solve(initialState StanfordAlgorithmState) (probl
 		// Test for Termination
 		r, err := stateII.GetReducedCostVector()
 		if err != nil {
-			return problem.Solution{}, fmt.Errorf(
+			return simplex_solution.SimplexSolution{}, fmt.Errorf(
 				"StanfordAlgorithm: Failed to get reduced cost vector (%v) at iteration #%v",
 				err,
 				iter,
@@ -248,7 +249,7 @@ func (algo *StanfordAlgorithm) Solve(initialState StanfordAlgorithmState) (probl
 		var ABasicInv mat.Dense
 		ABasic, err := stateII.ABasic()
 		if err != nil {
-			return problem.Solution{}, fmt.Errorf("StanfordAlgorithm: Failed to get ABasic matrix (%v)", err)
+			return simplex_solution.SimplexSolution{}, fmt.Errorf("StanfordAlgorithm: Failed to get ABasic matrix (%v)", err)
 		}
 		ABasicInv.Inverse(ABasic)
 		var ABasicAe mat.VecDense
@@ -263,7 +264,7 @@ func (algo *StanfordAlgorithm) Solve(initialState StanfordAlgorithmState) (probl
 			}
 		}
 		if objectiveIsUnboundedBelow {
-			return problem.Solution{}, fmt.Errorf(
+			return simplex_solution.SimplexSolution{}, fmt.Errorf(
 				"StanfordAlgorithm: Objective function is unbounded below, no solution exists at iteration %d",
 				iter,
 			)
@@ -274,13 +275,13 @@ func (algo *StanfordAlgorithm) Solve(initialState StanfordAlgorithmState) (probl
 		// Compute the feasible Solution of the Basic variables
 		xBasicII, err := algo.ComputeFeasibleBasicSolution(stateII)
 		if err != nil {
-			return problem.Solution{}, err
+			return simplex_solution.SimplexSolution{}, err
 		}
 
 		// Compute the value of the objective function
 		objII, err := algo.ComputeObjectiveFunctionValueWithFeasibleBasicSolution(stateII, xBasicII)
 		if err != nil {
-			return problem.Solution{}, err
+			return simplex_solution.SimplexSolution{}, err
 		}
 		fmt.Printf("Iteration %d: Basic Solution: %v, Objective Value: %f\n", iter, xBasicII, objII)
 
@@ -290,13 +291,12 @@ func (algo *StanfordAlgorithm) Solve(initialState StanfordAlgorithmState) (probl
 		// Check if the solution is optimal
 
 		if iter == algo.IterationLimit {
-			return problem.Solution{
-				Objective: objII,
-				Status:    problem.OptimizationStatus_ITERATION_LIMIT,
+			return simplex_solution.SimplexSolution{
+				Status: solution_status.ITERATION_LIMIT,
 			}, nil
 		}
 
 	}
 
-	return problem.Solution{}, nil
+	return simplex_solution.SimplexSolution{}, nil
 }

algorithms/tableau/errors.go

@@ -0,0 +1,18 @@
+package tableau_algorithm1
+
+type VariableSelectionError struct {
+	EnteringVarIndex int
+	ExitingVarIndex  int
+}
+
+func (e VariableSelectionError) Error() string {
+	if e.ExitingVarIndex == -1 {
+		return "VariableSelectionError: No exiting variable found, problem can not be improved."
+	}
+
+	if e.EnteringVarIndex == -1 {
+		return "VariableSelectionError: No entering variable found, current solution is optimal."
+	}
+
+	return "VariableSelectionError: Unknown variable selection error."
+}

algorithms/tableau/selection/blands_rule.go

@@ -2,7 +2,9 @@ package selection
 
 import (
 	"fmt"
+	"math"
 
+	"github.com/MatProGo-dev/SymbolicMath.go/symbolic"
 	"github.com/MatProGo-dev/simplex/utils"
 )
 
@@ -55,7 +57,7 @@ Description:
 func (br BlandsRule) SelectExitingVariable(tableau utils.Tableau, enteringVarIdx int) int {
 	// Setup
 	minIndex := -1
-	minRatio := -1.0
+	minRatio := float64(symbolic.Infinity)
 
 	// Get the relevant matrices
 	A := tableau.A()
@@ -64,7 +66,7 @@ func (br BlandsRule) SelectExitingVariable(tableau utils.Tableau, enteringVarIdx
 	// Create the vector of ratios
 	ratios := make([]float64, tableau.NumberOfConstraints())
 	for i := 0; i < tableau.NumberOfConstraints(); i++ {
-		if A.At(i, enteringVarIdx) > 0 {
+		if math.Abs(A.At(i, enteringVarIdx)) > 1e-12 {
 			ratios[i] = b.AtVec(i) / A.At(i, enteringVarIdx)
 		} else {
 			ratios[i] = -1.0 // Indicate that this variable cannot be used
@@ -74,7 +76,7 @@ func (br BlandsRule) SelectExitingVariable(tableau utils.Tableau, enteringVarIdx
 	// Iterate through the ratios and find the smallest one
 	for i, ratio := range ratios {
 		if ratio >= 0 { // Only consider valid ratios
-			if minRatio < 0 || ratio < minRatio || (ratio == minRatio && tableau.BasicVariableIndicies[i] < tableau.BasicVariableIndicies[minIndex]) {
+			if ratio < minRatio || (ratio == minRatio && tableau.BasicVariableIndicies[i] < tableau.BasicVariableIndicies[minIndex]) {
 				minRatio = ratio
 				minIndex = i
 			}
@@ -98,10 +100,12 @@ func (br BlandsRule) SelectEnteringAndExitingVariables(tableau utils.Tableau) (i
 		return -1, -1, nil // Optimal solution found, no entering variable
 	}
 
+	fmt.Println("Entering variable index:", enteringVarIdx)
+
 	// Select the exiting variable
 	exitingVarIdx := br.SelectExitingVariable(tableau, enteringVarIdx)
 	if exitingVarIdx == -1 {
-		return enteringVarIdx, -1, fmt.Errorf("BlandsRule: No exiting variable found, problem is unbounded (?)")
+		return enteringVarIdx, -1, fmt.Errorf("BlandsRule: No exiting variable found, problem can not be improved.")
 	}
 
 	return enteringVarIdx, exitingVarIdx, nil