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

Shortcuts on this page

r m x   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

113 statements  

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 self.assertIsInstance(v.str_without(), str) 

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

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

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

64 

65 def test_constraint_gen(self): 

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

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

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

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

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

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

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

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

74 

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

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

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

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

79 p = x**2 

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

81 d = p.sum() 

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

83 

84 def test_units(self): 

85 # inspired by gpkit issue #106 

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

87 constraints = (c == 1*gpkit.units.m) 

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

89 # test an array with inconsistent units 

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

91 pywarnings.simplefilter("ignore") 

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

93 self.assertRaises(DimensionalityError, mismatch.sum) 

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

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

96 

97 def test_sum(self): 

98 x = VectorVariable(5, 'x') 

99 p = x.sum() 

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

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

102 

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

104 rowsum = x.sum(axis=1) 

105 colsum = x.sum(axis=0) 

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

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

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

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

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

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

112 

113 def test_getitem(self): 

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

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

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

117 

118 def test_prod(self): 

119 x = VectorVariable(3, 'x') 

120 m = x.prod() 

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

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

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

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

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

126 

127 def test_outer(self): 

128 x = VectorVariable(3, 'x') 

129 y = VectorVariable(3, 'y') 

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

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

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

133 

134 def test_empty(self): 

135 x = VectorVariable(3, 'x') 

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

137 empty_posy_array = x[:0] 

138 self.assertRaises(ValueError, empty_posy_array.sum) 

139 self.assertRaises(ValueError, empty_posy_array.prod) 

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

141 self.assertEqual(empty_posy_array.ndim, 1) 

142 

143 

144TESTS = [TestNomialArray] 

145 

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

147 # pylint: disable=wrong-import-position 

148 from gpkit.tests.helpers import run_tests 

149 run_tests(TESTS)