Coverage for gpkit/tests/t_nomial_array.py: 100%

113 statements  

« prev     ^ index     » next       coverage.py v7.4.0, created at 2024-01-07 22:13 -0500

1"""Tests for NomialArray class""" 

2import unittest 

3import warnings as pywarnings 

4import numpy as np 

5from gpkit import Variable, Posynomial, NomialArray, VectorVariable, Monomial 

6from gpkit.constraints.set import ConstraintSet 

7from gpkit.exceptions import DimensionalityError 

8import gpkit 

9 

10 

11class TestNomialArray(unittest.TestCase): 

12 """TestCase for the NomialArray class. 

13 Also tests VectorVariable, since VectorVariable returns a NomialArray 

14 """ 

15 

16 def test_shape(self): 

17 x = VectorVariable((2, 3), 'x') 

18 self.assertEqual(x.shape, (2, 3)) 

19 self.assertIsInstance(x.str_without(), str) 

20 self.assertIsInstance(x.latex(), str) 

21 

22 def test_ndim(self): 

23 x = VectorVariable((3, 4), 'x') 

24 self.assertEqual(x.ndim, 2) 

25 

26 def test_array_mult(self): 

27 x = VectorVariable(3, 'x', label='dummy variable') 

28 x_0 = Variable('x', idx=(0,), shape=(3,), label='dummy variable') 

29 x_1 = Variable('x', idx=(1,), shape=(3,), label='dummy variable') 

30 x_2 = Variable('x', idx=(2,), shape=(3,), label='dummy variable') 

31 p = x_0**2 + x_1**2 + x_2**2 

32 self.assertEqual(x.dot(x), p) 

33 m = NomialArray([[x_0**2, x_0*x_1, x_0*x_2], 

34 [x_0*x_1, x_1**2, x_1*x_2], 

35 [x_0*x_2, x_1*x_2, x_2**2]]) 

36 self.assertEqual(x.outer(x), m) 

37 

38 def test_elementwise_mult(self): 

39 m = Variable('m') 

40 x = VectorVariable(3, 'x', label='dummy variable') 

41 x_0 = Variable('x', idx=(0,), shape=(3,), label='dummy variable') 

42 x_1 = Variable('x', idx=(1,), shape=(3,), label='dummy variable') 

43 x_2 = Variable('x', idx=(2,), shape=(3,), label='dummy variable') 

44 # multiplication with numbers 

45 v = NomialArray([2, 2, 3]).T 

46 p = NomialArray([2*x_0, 2*x_1, 3*x_2]).T 

47 self.assertEqual(x*v, p) 

48 # division with numbers 

49 p2 = NomialArray([x_0/2, x_1/2, x_2/3]).T 

50 self.assertEqual(x/v, p2) 

51 # power 

52 p3 = NomialArray([x_0**2, x_1**2, x_2**2]).T 

53 self.assertEqual(x**2, p3) 

54 # multiplication with monomials 

55 p = NomialArray([m*x_0, m*x_1, m*x_2]).T 

56 self.assertEqual(x*m, p) 

57 # division with monomials 

58 p2 = NomialArray([x_0/m, x_1/m, x_2/m]).T 

59 self.assertEqual(x/m, p2) 

60 # pylint: disable=no-member 

61 self.assertIsInstance(v.str_without(), str) 

62 self.assertIsInstance(v.latex(), str) 

63 self.assertIsInstance(p.str_without(), str) 

64 self.assertIsInstance(p.latex(), str) 

65 

66 def test_constraint_gen(self): 

67 x = VectorVariable(3, 'x', label='dummy variable') 

68 x_0 = Variable('x', idx=(0,), shape=(3,), label='dummy variable') 

69 x_1 = Variable('x', idx=(1,), shape=(3,), label='dummy variable') 

70 x_2 = Variable('x', idx=(2,), shape=(3,), label='dummy variable') 

71 v = NomialArray([1, 2, 3]).T 

72 p = [x_0, x_1/2, x_2/3] 

73 constraint = ConstraintSet([x <= v]) 

74 self.assertEqual(list(constraint.as_hmapslt1({})), [e.hmap for e in p]) 

75 

76 def test_substition(self): # pylint: disable=no-member 

77 x = VectorVariable(3, 'x', label='dummy variable') 

78 c = {x: [1, 2, 3]} 

79 self.assertEqual(x.sub(c), [Monomial({}, e) for e in [1, 2, 3]]) 

80 p = x**2 

81 self.assertEqual(p.sub(c), [Monomial({}, e) for e in [1, 4, 9]]) # pylint: disable=no-member 

82 d = p.sum() 

83 self.assertEqual(d.sub(c), Monomial({}, 14)) # pylint: disable=no-member 

84 

85 def test_units(self): 

86 # inspired by gpkit issue #106 

87 c = VectorVariable(5, "c", "m", "Local Chord") 

88 constraints = c == 1*gpkit.units.m 

89 self.assertEqual(len(constraints), 5) 

90 # test an array with inconsistent units 

91 with pywarnings.catch_warnings(): # skip the UnitStrippedWarning 

92 pywarnings.simplefilter("ignore") 

93 mismatch = NomialArray([1*gpkit.units.m, 1*gpkit.ureg.ft, 1.0]) 

94 self.assertRaises(DimensionalityError, mismatch.sum) 

95 self.assertEqual(mismatch[:2].sum().c, 1.3048*gpkit.ureg.m) # pylint:disable=no-member 

96 self.assertEqual(mismatch.prod().c, 1*gpkit.ureg.m*gpkit.ureg.ft) # pylint:disable=no-member 

97 

98 def test_sum(self): 

99 x = VectorVariable(5, 'x') 

100 p = x.sum() 

101 self.assertTrue(isinstance(p, Posynomial)) 

102 self.assertEqual(p, sum(x)) 

103 

104 x = VectorVariable((2, 3), 'x') 

105 rowsum = x.sum(axis=1) 

106 colsum = x.sum(axis=0) 

107 self.assertTrue(isinstance(rowsum, NomialArray)) 

108 self.assertTrue(isinstance(colsum, NomialArray)) 

109 self.assertEqual(rowsum[0], sum(x[0])) 

110 self.assertEqual(colsum[0], sum(x[:, 0])) 

111 self.assertEqual(len(rowsum), 2) 

112 self.assertEqual(len(colsum), 3) 

113 

114 def test_getitem(self): 

115 x = VectorVariable((2, 4), 'x') 

116 self.assertTrue(isinstance(x[0][0], Monomial)) 

117 self.assertTrue(isinstance(x[0, 0], Monomial)) 

118 

119 def test_prod(self): 

120 x = VectorVariable(3, 'x') 

121 m = x.prod() 

122 self.assertTrue(isinstance(m, Monomial)) 

123 self.assertEqual(m, x[0]*x[1]*x[2]) 

124 self.assertEqual(m, np.prod(x)) 

125 pows = NomialArray([x[0], x[0]**2, x[0]**3]) 

126 self.assertEqual(pows.prod(), x[0]**6) 

127 

128 def test_outer(self): 

129 x = VectorVariable(3, 'x') 

130 y = VectorVariable(3, 'y') 

131 self.assertEqual(np.outer(x, y), x.outer(y)) 

132 self.assertEqual(np.outer(y, x), y.outer(x)) 

133 self.assertTrue(isinstance(x.outer(y), NomialArray)) 

134 

135 def test_empty(self): 

136 x = VectorVariable(3, 'x') 

137 # have to create this using slicing, to get object dtype 

138 empty_posy_array = x[:0] 

139 self.assertRaises(ValueError, empty_posy_array.sum) 

140 self.assertRaises(ValueError, empty_posy_array.prod) 

141 self.assertEqual(len(empty_posy_array), 0) 

142 self.assertEqual(empty_posy_array.ndim, 1) 

143 

144 

145TESTS = [TestNomialArray] 

146 

147if __name__ == "__main__": # pragma: no cover 

148 # pylint: disable=wrong-import-position 

149 from gpkit.tests.helpers import run_tests 

150 run_tests(TESTS)