Changed how we concretize matrix and vectors of monomials

Author: Kwesi Rutledge

symbolic/monomial.go

@@ -543,7 +543,11 @@ func (m Monomial) DerivativeWrt(vIn Variable) Expression {
 		// monomial.
 		var monomialOut Monomial
 
-		if m.Exponents[foundIndex] == 1 {
+		switch {
+		case (m.Exponents[foundIndex] == 1) && (len(m.VariableFactors) == 1):
+			// Return the exponent
+			return K(m.Coefficient)
+		case m.Exponents[foundIndex] == 1:
 			// If the degree of vIn is 1, then remove it from the monomial
 			monomialOut.Coefficient = m.Coefficient
 			for ii, variable := range m.VariableFactors {
@@ -552,7 +556,7 @@ func (m Monomial) DerivativeWrt(vIn Variable) Expression {
 					monomialOut.Exponents = append(monomialOut.Exponents, m.Exponents[ii])
 				}
 			}
-		} else {
+		default:
 			monomialOut = m
 			monomialOut.Coefficient = m.Coefficient * float64(m.Exponents[foundIndex])
 			monomialOut.Exponents[foundIndex] -= 1

symbolic/monomial_matrix.go

@@ -505,30 +505,19 @@ func (mm MonomialMatrix) DerivativeWrt(vIn Variable) Expression {
 	}
 
 	// Compute the Derivative of each monomial
-	var dmm MonomialMatrix
+	var dmm [][]ScalarExpression
 	for _, row := range mm {
-		var dmmRow []Monomial
+		var dmmRow []ScalarExpression
 		for _, monomial := range row {
 			dMonomial := monomial.DerivativeWrt(vIn)
-			var dMonomialAsMonomial Monomial
-			switch dMonomial.(type) {
-			case Monomial:
-				dMonomialAsMonomial = dMonomial.(Monomial)
-			case K:
-				dMonomialAsMonomial = dMonomial.(K).ToMonomial()
-			default:
-				panic(
-					fmt.Errorf("unexpected type of derivative: %T (%v)", dMonomial, dMonomial),
-				)
-			}
-			// Add the converted dMonomial to dmmRow
-			dmmRow = append(dmmRow, dMonomialAsMonomial)
+			dMonomialAsSE, _ := ToScalarExpression(dMonomial)
+			dmmRow = append(dmmRow, dMonomialAsSE) // Add the converted dMonomial to dmmRow
 		}
 		dmm = append(dmm, dmmRow)
 	}
 
 	// Return the derivative
-	return dmm
+	return ConcretizeMatrixExpression(dmm)
 }
 
 /*

testing/symbolic/monomial_matrix_test.go

@@ -1634,6 +1634,175 @@ func TestMonomialMatrix_Eq2(t *testing.T) {
 	}
 }
 
+/*
+TestMonomialMatrix_DerivativeWrt1
+Description:
+
+	This test checks that the DerivativeWrt() method properly panics when it is called
+	with a monomial matrix that is not well formed.
+*/
+func TestMonomialMatrix_DerivativeWrt1(t *testing.T) {
+	// Constants
+	var mm symbolic.MonomialMatrix
+
+	// Test
+	defer func() {
+		r := recover()
+		if r == nil {
+			t.Errorf(
+				"expected DerivativeWrt() to panic; it did not",
+			)
+		}
+
+		rAsE, ok := r.(error)
+		if !ok {
+			t.Errorf(
+				"expected DerivativeWrt() to panic with an error; it panicked with %v",
+				r,
+			)
+		}
+
+		expectedError := mm.Check()
+		if !strings.Contains(rAsE.Error(), expectedError.Error()) {
+			t.Errorf(
+				"expected DerivativeWrt() to panic with error \"%v\"; it panicked with \"%v\"",
+				expectedError,
+				rAsE,
+			)
+		}
+	}()
+	mm.DerivativeWrt(symbolic.NewVariable())
+}
+
+/*
+TestMonomialMatrix_DerivativeWrt2
+Description:
+
+	This test checks that the DerivativeWrt() method properly panics when it is called
+	with a monomial matrix that is well-formed and a variable that is not well-defined.
+*/
+func TestMonomialMatrix_DerivativeWrt2(t *testing.T) {
+	// Constants
+	v1 := symbolic.NewVariable()
+	badV := symbolic.Variable{}
+	m1 := v1.ToMonomial()
+	var mm symbolic.MonomialMatrix = [][]symbolic.Monomial{
+		{m1, m1},
+		{m1, m1},
+	}
+
+	// Test
+	defer func() {
+		r := recover()
+		if r == nil {
+			t.Errorf(
+				"expected DerivativeWrt() to panic; it did not",
+			)
+		}
+
+		rAsE, ok := r.(error)
+		if !ok {
+			t.Errorf(
+				"expected DerivativeWrt() to panic with an error; it panicked with %v",
+				r,
+			)
+		}
+
+		expectedError := badV.Check()
+		if !strings.Contains(rAsE.Error(), expectedError.Error()) {
+			t.Errorf(
+				"expected DerivativeWrt() to panic with error \"%v\"; it panicked with \"%v\"",
+				expectedError,
+				rAsE,
+			)
+		}
+	}()
+
+	mm.DerivativeWrt(badV)
+}
+
+/*
+TestMonomialMatrix_DerivativeWrt3
+Description:
+
+	This test checks that the DerivativeWrt() method properly returns a matrix of
+	monomials that are the derivatives of the original monomials with respect to
+	the given variable.
+*/
+func TestMonomialMatrix_DerivativeWrt3(t *testing.T) {
+	// Constants
+	v1 := symbolic.NewVariable()
+	v2 := symbolic.NewVariable()
+	m1 := v1.ToMonomial()
+	m2 := v2.ToMonomial()
+	var mm symbolic.MonomialMatrix = [][]symbolic.Monomial{
+		{m1, m2},
+		{m1, m2},
+	}
+
+	// Test
+	derivatives := mm.DerivativeWrt(v1)
+
+	// Check that the dimensions of the derivatives are (2,2)
+	if dims := derivatives.Dims(); dims[0] != 2 || dims[1] != 2 {
+		t.Errorf(
+			"expected DerivativeWrt() to return a MonomialMatrix with dimensions (2,2); received %v",
+			dims,
+		)
+	}
+
+	dAsMM, ok := derivatives.(symbolic.KMatrix)
+	if !ok {
+		t.Errorf(
+			"expected DerivativeWrt() to return a MonomialMatrix; received %T",
+			derivatives,
+		)
+
+	}
+
+	// Check that the derivatives are correct
+	for ii, row := range dAsMM {
+		for jj, derivative := range row {
+			// Check that the derivative is the correct monomial
+			if ii == 0 {
+				if jj == 0 {
+					if float64(derivative) != 1.0 {
+						t.Errorf(
+							"expected DerivativeWrt() to return a MonomialMatrix with derivative %v at (0,0); received %v",
+							1.0,
+							derivative,
+						)
+					}
+				} else {
+					if float64(derivative) != 0.0 {
+						t.Errorf(
+							"expected DerivativeWrt() to return a MonomialMatrix with derivative 0.0 at (0,1); received %v",
+							derivative,
+						)
+					}
+				}
+			} else {
+				if jj == 0 {
+					if float64(derivative) != 1.0 {
+						t.Errorf(
+							"expected DerivativeWrt() to return a MonomialMatrix with derivative %v at (1,1); received %v",
+							1.0,
+							derivative,
+						)
+					}
+				} else {
+					if float64(derivative) != 0.0 {
+						t.Errorf(
+							"expected DerivativeWrt() to return a MonomialMatrix with derivative 0.0 at (1,0); received %v",
+							derivative,
+						)
+					}
+				}
+			}
+		}
+	}
+}
+
 /*
 TestMonomialMatrix_Transpose2
 Description:

testing/symbolic/monomial_test.go

@@ -1460,8 +1460,8 @@ func TestMonomial_DerivativeWrt2(t *testing.T) {
 	// Compute DerivativeWrt
 	derivative := m1.DerivativeWrt(v1)
 
-	// Verify that the derivative is a monomial
-	derivativeAsM, tf := derivative.(symbolic.Monomial)
+	// Verify that the derivative is a constant (K)
+	derivativeAsK, tf := derivative.(symbolic.K)
 	if !tf {
 		t.Errorf(
 			"expected derivative to be a monomial; received %T",
@@ -1470,10 +1470,10 @@ func TestMonomial_DerivativeWrt2(t *testing.T) {
 	}
 
 	// Verify that the derivative is a constant
-	if derivativeAsM.Coefficient != 3.14 {
+	if float64(derivativeAsK) != 3.14 {
 		t.Errorf(
 			"expected derivative to be a constant; received %v",
-			derivativeAsM.Coefficient,
+			derivativeAsK,
 		)
 	}
 }

testing/symbolic/monomial_vector_test.go

@@ -1626,7 +1626,7 @@ func TestMonomialVector_Derivative3(t *testing.T) {
 	derivative := mv.DerivativeWrt(v1)
 
 	// Verify that the derivative is a K vector
-	if _, tf := derivative.(symbolic.MonomialVector); !tf {
+	if _, tf := derivative.(symbolic.KVector); !tf {
 		t.Errorf(
 			"expected derivative to be a MonomialVector; received %T",
 			derivative,
@@ -1635,20 +1635,12 @@ func TestMonomialVector_Derivative3(t *testing.T) {
 
 	// Verify that each element of the derivative is just the coefficient
 	// from the original monomial vector mv
-	for ii, monomial := range derivative.(symbolic.MonomialVector) {
-		// Check that the monomial is a constant
-		if !monomial.IsConstant() {
-			t.Errorf(
-				"expected monomial to be a constant; received %v",
-				monomial,
-			)
-		}
-
-		if monomial.Coefficient != mv[ii].Coefficient {
+	for ii, d_ii := range derivative.(symbolic.KVector) {
+		if float64(d_ii) != mv[ii].Coefficient {
 			t.Errorf(
 				"expected constant to be %v; received %v",
 				mv[ii].Coefficient,
-				monomial.Coefficient,
+				float64(d_ii),
 			)
 		}
 	}
@@ -1683,7 +1675,7 @@ func TestMonomialVector_Derivative4(t *testing.T) {
 	derivative := mv.DerivativeWrt(v1)
 
 	// Verify that the derivative is a K vector
-	d_v1, tf := derivative.(symbolic.MonomialVector)
+	d_v1, tf := derivative.(symbolic.KVector)
 	if !tf {
 		t.Errorf(
 			"expected derivative to be a MonomialVector; received %T",
@@ -1692,32 +1684,18 @@ func TestMonomialVector_Derivative4(t *testing.T) {
 	}
 
 	// Verify that the first element of the derivative is a constant and nonzero
-	if !d_v1[0].IsConstant() {
-		t.Errorf(
-			"expected derivative[0] to be a constant; received %v",
-			d_v1[0],
-		)
-	}
-
-	if d_v1[0].Coefficient != 3.14 {
+	if float64(d_v1[0]) != 3.14 {
 		t.Errorf(
 			"expected derivative[0].Coefficient to be 3.14; received %v",
-			d_v1[0].Coefficient,
+			d_v1[0],
 		)
 	}
 
 	// Verify that the second element of the derivative is a constant and zero
-	if !d_v1[1].IsConstant() {
-		t.Errorf(
-			"expected derivative[1] to be a constant; received %v",
-			d_v1[1],
-		)
-	}
-
-	if d_v1[1].Coefficient != 0 {
+	if float64(d_v1[1]) != 0 {
 		t.Errorf(
 			"expected derivative[1].Coefficient to be 0; received %v",
-			d_v1[1].Coefficient,
+			d_v1[1],
 		)
 	}