Introduced Some Basic Substitution Features (#12)

* Adding the New Required Methods Substitute and SubstituteAccordingTo to Expression object

* Adding the Substitute and SubstituteAccordingTo methods to Constant-like objects

* Introduced Power Function (need tests!)

* Introduced Substitution Functions

* Reverted substitution map to use map[Variable]Expression and introduced checking function for it

* Added Tests for Variable.Substitute and a few other functions

* Added Tests for KMatrix Substitute, Degree, SubstituteAccordingTo, and Power

* Added Tests for Concretizing Vector Expressions

* Added Tests for Checking Substitution Map

* Added Tests for MonomialVector.Minus

* Added Tests for MonomialVector.Degree and MonomialVector.Power

* Added Tests for MatrixExpression.ConcretizeMatrixExpression

* Added Tests for Variable.Power, Variable.SubstituteAccordingTo

* Added Tests for Monomial.Minus

* Added Tests for Monomial.Minus

* Modified coverage file so that we don't consider the examples directory

* Removed extraneous switch in Monomial.Minus + modified the IsVectorExpression and IsMatrixExpression

* Modified ToVectorExpression as well

* Added More Tests for Monomial.Multiply() and Monomial.DerivativeWrt()

* Added Tests for ScalarExpression.ScalarPowerTemplate

* Updated ConstantMatrix.Multiply to accept more types + added tests for more Polynomial functions

* Added Tests for MatrixSubstituteTemplate and MatrixPowerTemplate

* Simplified Some of VectorExpression functions and added tests for error handling in VectorExpression templates

* Modified VariableVector.Minus() (to simplify it) and tested it

* Added Simple Test of Power Function

* Added Simple Test of MonomialMatrix.Substitute and MonomialMatrix.Minus Functions

* Changed how we concretize matrix and vectors of monomials

* Added tests for MonomialMatrix.SubstituteAccordingTo

---------

Co-authored-by: Kwesi Rutledge <[email protected]>

Author: kwesiRutledge

Diff for: .github/workflows/coverage1.yml

@@ -36,7 +36,7 @@ jobs:
 
       - name: Test Coverage
         run: |
-          go test -v -cover ./... -coverprofile coverage.out -coverpkg ./...
+          go test -v -cover $(go list ./... | grep -v /examples/) -coverprofile coverage.out -coverpkg ./...
           go tool cover -func coverage.out -o coverage2.out  
 
       - name: Upload coverage reports to Codecov

Diff for: README.md

@@ -64,8 +64,10 @@ This project was motivated by the need for a symbolic math package for defining
 optimization and control theory problems in Go, but symbolic mathematics is a topic that covers
 a wide range of applications. If this tool is not useful for your purpose, then you might
 find one of the following projects more helpful:
+
 While other symbolic math libraries exist for Go, they typically focus on:
 - Computer Algebra Systems that will help you get a final expression (in text) from
 arbitrary math input (often in text) \[[expreduce](https://github.com/corywalker/expreduce),[sm](https://github.com/Konstantin8105/sm)\]
 - Implementing Algorithms from [Domain-Specific Languages of Mathematics](https://github.com/DSLsofMath/DSLsofMath)
   Course \[[gosymbol](https://github.com/victorbrun/gosymbol/tree/main)\]
+- Machine Learning and algorithms needed to perform automatic differentiation \[[gorgonia](https://github.com/gorgonia/gorgonia)\]

Diff for: smErrors/negative_exponent.go

@@ -0,0 +1,20 @@
+package smErrors
+
+import "fmt"
+
+/*
+negative_exponent.go
+Description:
+
+	Functions related to the negative exponent error.
+*/
+
+// Type Definition
+type NegativeExponentError struct {
+	Exponent int
+}
+
+// Error
+func (e NegativeExponentError) Error() string {
+	return fmt.Sprintf("received negative exponent (%v); expected non-negative exponent", e.Exponent)
+}

Diff for: symbolic/constant.go

@@ -121,6 +121,10 @@ func (c K) Plus(rightIn interface{}) Expression {
 		// Convert to VectorExpression
 		ve, _ := ToVectorExpression(right)
 		return ve.Plus(c)
+	case mat.Dense:
+		return c.Plus(DenseToKMatrix(right))
+	case *mat.Dense:
+		return c.Plus(DenseToKMatrix(*right))
 	case KMatrix, VariableMatrix, MonomialMatrix, PolynomialMatrix:
 		// Convert to MatrixExpression
 		me, _ := ToMatrixExpression(right)
@@ -379,3 +383,33 @@ Description:
 func (c K) String() string {
 	return fmt.Sprintf("%v", float64(c))
 }
+
+/*
+Substitute
+Description:
+
+	Substitutes the variable vIn with the expression eIn.
+*/
+func (c K) Substitute(vIn Variable, eIn ScalarExpression) Expression {
+	return c
+}
+
+/*
+SubstituteAccordingTo
+Description:
+
+	Substitutes the variables in the map with the corresponding expressions.
+*/
+func (c K) SubstituteAccordingTo(subMap map[Variable]Expression) Expression {
+	return c
+}
+
+/*
+Power
+Description:
+
+	Computes the power of the constant.
+*/
+func (c K) Power(exponent int) Expression {
+	return ScalarPowerTemplate(c, exponent)
+}

Diff for: symbolic/constant_matrix.go

@@ -142,6 +142,23 @@ func (km KMatrix) Plus(e interface{}) Expression {
 
 		return km.Plus(rightAsVM) // Reuse VariableMatrix case
 
+	case mat.Dense:
+		return km.Plus(DenseToKMatrix(right)) // Reuse KMatrix case
+
+	case *mat.Dense:
+		return km.Plus(*right) // Reuse mat.Dense case
+
+	case KMatrix:
+		// Create the result matrix
+		var result KMatrix = make([][]K, nR)
+		for rIndex := 0; rIndex < nR; rIndex++ {
+			result[rIndex] = make([]K, nC)
+			for cIndex := 0; cIndex < nC; cIndex++ {
+				result[rIndex][cIndex] = km[rIndex][cIndex] + right[rIndex][cIndex]
+			}
+		}
+		return result
+
 	case VariableMatrix:
 		// Create the result matrix
 		var result PolynomialMatrix = make([][]Polynomial, nR)
@@ -257,6 +274,32 @@ func (km KMatrix) Multiply(e interface{}) Expression {
 
 	case K:
 		return km.Multiply(float64(right)) // Reuse float64 case
+	case Polynomial:
+		// Choose the correct output type based on the size of km
+		nR, nC := km.Dims()[0], km.Dims()[1]
+		switch {
+		case (nR == 1) && (nC == 1):
+			// If the output is a scalar, return a scalar
+			return km[0][0].Multiply(right)
+		case nC == 1:
+			// If the output is a vector, return a vector
+			var outputVec PolynomialVector = make([]Polynomial, nR)
+			for rIndex := 0; rIndex < nR; rIndex++ {
+				outputVec[rIndex] = km[rIndex][0].Multiply(right.Copy()).(Polynomial)
+			}
+			return outputVec
+		default:
+			// If the output is a matrix, return a matrix
+			var outputMat PolynomialMatrix = make([][]Polynomial, nR)
+			for rIndex := 0; rIndex < nR; rIndex++ {
+				outputMat[rIndex] = make([]Polynomial, nC)
+				for cIndex := 0; cIndex < nC; cIndex++ {
+					outputMat[rIndex][cIndex] = km[rIndex][cIndex].Multiply(right.Copy()).(Polynomial)
+				}
+			}
+			return outputMat
+		}
+
 	case *mat.VecDense:
 		// Use gonum's built-in multiplication function
 		var product mat.VecDense
@@ -673,3 +716,33 @@ Description:
 func (km KMatrix) Degree() int {
 	return 0
 }
+
+/*
+Substitute
+Description:
+
+	Substitutes all occurrences of variable vIn with the expression eIn.
+*/
+func (km KMatrix) Substitute(vIn Variable, eIn ScalarExpression) Expression {
+	return km
+}
+
+/*
+SubstituteAccordingTo
+Description:
+
+	Substitutes all occurrences of the variables in the map with the corresponding expressions.
+*/
+func (km KMatrix) SubstituteAccordingTo(subMap map[Variable]Expression) Expression {
+	return km
+}
+
+/*
+Power
+Description:
+
+	Raises the constant matrix to the power of the input integer.
+*/
+func (km KMatrix) Power(exponent int) Expression {
+	return MatrixPowerTemplate(km, exponent)
+}

Diff for: symbolic/constant_vector.go

@@ -591,3 +591,33 @@ Description:
 func (kv KVector) Degree() int {
 	return 0
 }
+
+/*
+Substitute
+Description:
+
+	Substitutes all occurrences of variable vIn with the expression eIn.
+*/
+func (kv KVector) Substitute(vIn Variable, eIn ScalarExpression) Expression {
+	return kv
+}
+
+/*
+SubstituteAccordingTo
+Description:
+
+	Substitutes all occurrences of the variables in the map with the corresponding expressions.
+*/
+func (kv KVector) SubstituteAccordingTo(subMap map[Variable]Expression) Expression {
+	return kv
+}
+
+/*
+Power
+Description:
+
+	Raises the scalar expression to the power of the input integer.
+*/
+func (kv KVector) Power(exponent int) Expression {
+	return VectorPowerTemplate(kv, exponent)
+}

Diff for: symbolic/constraint.go

@@ -12,6 +12,7 @@ type Constraint interface {
 	Right() Expression
 	ConstrSense() ConstrSense
 	Check() error
+	IsLinear() bool
 }
 
 func IsConstraint(c interface{}) bool {

Diff for: symbolic/expression.go

@@ -55,6 +55,16 @@ type Expression interface {
 
 	// String returns a string representation of the expression
 	String() string
+
+	// Substitute returns the expression with the variable vIn replaced with the expression eIn
+	Substitute(vIn Variable, eIn ScalarExpression) Expression
+
+	// SubstituteAccordingToMap returns the expression with the variables in the map replaced with the corresponding expressions
+	SubstituteAccordingTo(subMap map[Variable]Expression) Expression
+
+	// Power
+	// Raises the scalar expression to the power of the input integer
+	Power(exponent int) Expression
 }
 
 /*