Added support for multiplication on several important types of variables (#14)

* Added support for multiplication on several important types of variables

* Added a few more tests for coverage of the ConcretizeExpression function

---------

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

Author: kwesiRutledge

symbolic/expression.go

@@ -192,7 +192,7 @@ func HStack(eIn ...Expression) Expression {
 	// TODO: Panic if there are 0 expressions in the input
 	if len(eIn) == 0 {
 		panic(
-			fmt.Errorf("HStack: There must be at least one expression in the input; received 0."),
+			fmt.Errorf("HStack: There must be at least one expression in the input; received 0"),
 		)
 	}
 
@@ -293,9 +293,9 @@ func ConcretizeExpression(e interface{}) Expression {
 	var (
 		concrete Expression
 	)
-	switch e.(type) {
+	switch concreteVal := e.(type) {
 	case []ScalarExpression:
-		concreteVectorE := ConcretizeVectorExpression(e.([]ScalarExpression))
+		concreteVectorE := ConcretizeVectorExpression(concreteVal)
 		// If vector expression is a scalar (i.e., has 1 row), return the scalar expression
 		if concreteVectorE.Dims()[0] == 1 {
 			concrete = concreteVectorE.At(0, 0)
@@ -304,7 +304,7 @@ func ConcretizeExpression(e interface{}) Expression {
 		}
 
 	case [][]ScalarExpression:
-		concreteMatrixE := ConcretizeMatrixExpression(e.([][]ScalarExpression))
+		concreteMatrixE := ConcretizeMatrixExpression(concreteVal)
 		// If matrix expression is a scalar (i.e., has 1 row and 1 column), return the scalar expression
 		switch {
 		case concreteMatrixE.Dims()[0] == 1 && concreteMatrixE.Dims()[1] == 1: // If the matrix is a scalar

symbolic/variable_matrix.go

@@ -310,6 +310,21 @@ func (vm VariableMatrix) Multiply(e interface{}) Expression {
 	case mat.VecDense:
 		// Use the KVector case
 		return vm.Multiply(VecDenseToKVector(right))
+	case VariableVector:
+		// Output will be another vector
+		nVMCols := vm.Dims()[1]
+		var result Expression = K(0.0)
+		for ii := 0; ii < nVMCols; ii++ {
+			// Create a new vector from the ii-th column of the matrix
+			var vmCol VariableVector
+			for jj := 0; jj < vm.Dims()[0]; jj++ {
+				vmCol = append(vmCol, vm[jj][ii])
+			}
+			result = result.Plus(
+				vmCol.Multiply(right[ii]),
+			)
+		}
+		return result
 	case *mat.Dense:
 		// Use the mat.Dense case
 		return vm.Multiply(DenseToKMatrix(*right))

symbolic/variable_vector.go

@@ -288,6 +288,17 @@ func (vv VariableVector) Multiply(rightIn interface{}) Expression {
 			mvOut = append(mvOut, v.Multiply(right).(Monomial))
 		}
 		return mvOut
+	case Variable:
+		// Is output a scalar?
+		if nResultRows == 1 {
+			return vv[0].Multiply(right)
+		}
+		// Create a new vector of monomials.
+		var mvOut MonomialVector
+		for _, v := range vv {
+			mvOut = append(mvOut, v.Multiply(right).(Monomial))
+		}
+		return mvOut
 	case Monomial:
 		// Is output a scalar?
 		if nResultRows == 1 {

testing/symbolic/expression_test.go

@@ -1,6 +1,7 @@
 package symbolic_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/MatProGo-dev/SymbolicMath.go/smErrors"
@@ -250,6 +251,37 @@ func TestExpression_HStack5(t *testing.T) {
 	}
 }
 
+/*
+TestExpression_HStack6
+Description:
+
+	Tests that the HStack function panics when called with no arguments.
+*/
+func TestExpression_HStack6(t *testing.T) {
+	// Test
+	defer func() {
+		err := recover().(error)
+		if err == nil {
+			t.Errorf("The HStack function should panic when called with no arguments")
+		}
+
+		// Collect the expected error which should be a dimension error and
+		// compare it with the recovered error
+		expectedError := fmt.Errorf(
+			"HStack: There must be at least one expression in the input; received 0",
+		)
+		if err.Error() != expectedError.Error() {
+			t.Errorf(
+				"Expected the error to be %v; received %v",
+				expectedError,
+				err,
+			)
+		}
+
+	}()
+	symbolic.HStack()
+}
+
 /*
 TestExpression_VStack1
 Description:
@@ -464,3 +496,139 @@ func TestExpression_VStack6(t *testing.T) {
 		)
 	}
 }
+
+/*
+TestExpression_VStack7
+Description:
+
+	Tests that the VStack function panics when called with no arguments.
+*/
+func TestExpression_VStack7(t *testing.T) {
+	// Test
+	defer func() {
+		err := recover().(error)
+		if err == nil {
+			t.Errorf("The VStack function should panic when called with no arguments")
+		}
+
+		// Collect the expected error which should be a dimension error and
+		// compare it with the recovered error
+		expectedError := fmt.Errorf(
+			"VStack: There must be at least one expression in the input; received 0",
+		)
+		if err.Error() != expectedError.Error() {
+			t.Errorf(
+				"Expected the error to be %v; received %v",
+				expectedError,
+				err,
+			)
+		}
+
+	}()
+	symbolic.VStack()
+}
+
+/*
+TestExpression_ConcretizeExpression1
+Description:
+
+	Tests the ConcretizeExpression function for a slice of scalar expressions.
+	The result should be a monomial matrix with three rows and 1 column1.
+*/
+func TestExpression_ConcretizeExpression1(t *testing.T) {
+	// Constants
+	expressions := []symbolic.ScalarExpression{
+		symbolic.K(1.0),
+		symbolic.K(2.0),
+		symbolic.NewVariable(),
+	}
+
+	// Test
+	result := symbolic.ConcretizeExpression(expressions)
+	if result.Dims()[0] != 3 || result.Dims()[1] != 1 {
+		t.Errorf(
+			"Expected the result to be a 3x1 matrix; received %v",
+			result.Dims(),
+		)
+	}
+
+	// Verify that the result is a monomial matrix
+	if _, ok := result.(symbolic.MonomialVector); !ok {
+		t.Errorf(
+			"Expected the result to be a MonomialVector; received %T",
+			result,
+		)
+	}
+}
+
+/*
+TestExpression_ConcretizeExpression2
+Description:
+
+	Tests the ConcretizeExpression function for a slice of scalar expressions.
+	The slice contains only one scalar expression. This should return a scalar expression.
+*/
+func TestExpression_ConcretizeExpression2(t *testing.T) {
+	// Constants
+	expressions := []symbolic.ScalarExpression{
+		symbolic.K(1.0),
+	}
+
+	// Test
+	result := symbolic.ConcretizeExpression(expressions)
+	if result.Dims()[0] != 1 || result.Dims()[1] != 1 {
+		t.Errorf(
+			"Expected the result to be a 1x1 matrix; received %v",
+			result.Dims(),
+		)
+	}
+
+	// Verify that the result is a scalar expression
+	if _, ok := result.(symbolic.K); !ok {
+		t.Errorf(
+			"Expected the result to be a K; received %T",
+			result,
+		)
+	}
+}
+
+/*
+TestExpression_ConcretizeExpression3
+Description:
+
+	Tests the ConcretizeExpression function for a slice of slices of scalar expressions.
+	The result should be a monomial matrix with three rows and 2 columns.
+*/
+func TestExpression_ConcretizeExpression3(t *testing.T) {
+	// Constants
+	expressions := [][]symbolic.ScalarExpression{
+		{
+			symbolic.K(1.0),
+			symbolic.K(2.0),
+		}, {
+			symbolic.K(3.0),
+			symbolic.NewVariable(),
+		},
+		{
+			symbolic.K(4.0),
+			symbolic.NewVariable(),
+		},
+	}
+
+	// Test
+	result := symbolic.ConcretizeExpression(expressions)
+	if result.Dims()[0] != 3 || result.Dims()[1] != 2 {
+		t.Errorf(
+			"Expected the result to be a 3x2 matrix; received %v",
+			result.Dims(),
+		)
+	}
+
+	// Verify that the result is a monomial matrix
+	if _, ok := result.(symbolic.MonomialMatrix); !ok {
+		t.Errorf(
+			"Expected the result to be a MonomialMatrix; received %T",
+			result,
+		)
+	}
+}

testing/symbolic/variable_matrix_test.go

@@ -1057,6 +1057,36 @@ func TestVariableMatrix_Multiply14(t *testing.T) {
 	}
 }
 
+/*
+TestVariableMatrix_Multiply15
+Description:
+
+	Tests the Multiply method for a VariableMatrix object that is well-defined
+	of a dimension (3, 2) being multiplied by a VariableVector of dimension (2, 1).
+	The product should be a PolynomialVector of dimension (3, 1) with two monomials in each polynomial.
+*/
+func TestVariableMatrix_Multiply15(t *testing.T) {
+	// Constants
+	vm2 := symbolic.NewVariableMatrix(3, 2)
+	vv1 := symbolic.NewVariableVector(2)
+
+	// Compute Product
+	result := vm2.Multiply(vv1)
+
+	// Check that object is a PolynomialVector
+	if _, ok := result.(symbolic.PolynomialVector); !ok {
+		t.Errorf("Expected Multiply to return a PolynomialVector; received %T", result)
+	}
+
+	// Check that each polynomial in the result contains two monomials.
+	pv := result.(symbolic.PolynomialVector)
+	for i := 0; i < pv.Dims()[0]; i++ {
+		if len(pv[i].Monomials) != 2 {
+			t.Errorf("Expected each polynomial to contain 2 monomials; received %v", len(pv[i].Monomials))
+		}
+	}
+}
+
 /*
 TestVariableMatrix_Transpose1
 Description:

testing/symbolic/variable_vector_test.go

@@ -7,12 +7,13 @@ Description:
 */
 
 import (
+	"strings"
+	"testing"
+
 	getKMatrix "github.com/MatProGo-dev/SymbolicMath.go/get/KMatrix"
 	getKVector "github.com/MatProGo-dev/SymbolicMath.go/get/KVector"
 	"github.com/MatProGo-dev/SymbolicMath.go/smErrors"
 	"github.com/MatProGo-dev/SymbolicMath.go/symbolic"
-	"strings"
-	"testing"
 )
 
 /*
@@ -1007,8 +1008,46 @@ func TestVariableVector_Multiply11(t *testing.T) {
 
 /*
 TestVariableVector_Multiply12
+Description:
 
+	This test verifies that the multiplication of a well-formed variable vector
+	of length 11 with a well-formed variable (scalar) returns a monomial vector.
 */
+func TestVariableVector_Multiply12(t *testing.T) {
+	// Constants
+	N := 11
+	vv1 := symbolic.NewVariableVector(N)
+	v2 := symbolic.NewVariable()
+
+	// Test
+	r := vv1.Multiply(v2)
+	if _, ok := r.(symbolic.MonomialVector); !ok {
+		t.Errorf(
+			"Expected vv1.Multiply(v2) to return a Monomial object; received %T",
+			r,
+		)
+	}
+
+	// Each element of the monomial vector should contain the variable v2
+	rAsMV, _ := r.(symbolic.MonomialVector)
+	for ii := 0; ii < N; ii++ {
+		monomialII := rAsMV.AtVec(ii).(symbolic.Monomial)
+		v2Found := false
+		for _, variableJJInII := range monomialII.Variables() {
+			if variableJJInII.ID == v2.ID {
+				v2Found = true
+			}
+		}
+		if !v2Found {
+			t.Errorf(
+				"Expected r.AtVec(%v) to contain v2; received %v",
+				ii,
+				monomialII,
+			)
+		}
+	}
+
+}
 
 /*
 TestVariableVector_Comparison1