diff options
Diffstat (limited to 'numpy/doc/swig/test1D.py')
| -rwxr-xr-x | numpy/doc/swig/test1D.py | 290 |
1 files changed, 156 insertions, 134 deletions
diff --git a/numpy/doc/swig/test1D.py b/numpy/doc/swig/test1D.py index 23cc3cb17..b1909c5b7 100755 --- a/numpy/doc/swig/test1D.py +++ b/numpy/doc/swig/test1D.py @@ -16,669 +16,691 @@ else: BadListError = ValueError # import the extension module libDir = "lib.%s-%s" % (get_platform(), sys.version[:3]) sys.path.insert(0,os.path.join("build", libDir)) -import Series +import Vector ###################################################################### -class SeriesTestCase(unittest.TestCase): +class VectorTestCase(unittest.TestCase): #################################################### ### Test functions that take arrays of type BYTE ### def testScharLength(self): "Test scharLength function" - self.assertEquals(Series.scharLength([5, 12, 0]), 13) + self.assertEquals(Vector.scharLength([5, 12, 0]), 13) def testScharLengthBad(self): "Test scharLength function for wrong size" - self.assertRaises(TypeError, Series.scharLength, [5, 12]) + self.assertRaises(TypeError, Vector.scharLength, [5, 12]) def testScharProd(self): "Test scharProd function" - self.assertEquals(Series.scharProd([1,2,3,4]), 24) + self.assertEquals(Vector.scharProd([1,2,3,4]), 24) def testScharProdNonContainer(self): "Test scharProd function with None" - self.assertRaises(TypeError, Series.scharProd, None) + self.assertRaises(TypeError, Vector.scharProd, None) def testScharSum(self): "Test scharSum function" - self.assertEquals(Series.scharSum([-5,6,-7,8]), 2) + self.assertEquals(Vector.scharSum([-5,6,-7,8]), 2) def testScharReverse(self): "Test scharReverse function" vector = N.array([1,2,4],'b') - Series.scharReverse(vector) + Vector.scharReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testScharOnes(self): "Test scharOnes function" myArray = N.zeros(5,'b') - Series.scharOnes(myArray) + Vector.scharOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testScharZeros(self): "Test scharZeros function" myArray = N.ones(5,'b') - Series.scharZeros(myArray) + Vector.scharZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testScharEOSplit(self): "Test scharEOSplit function" - even, odd = Series.scharEOSplit([1,2,3]) + even, odd = Vector.scharEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testScharTwos(self): "Test scharTwos function" - twos = Series.scharTwos(5) + twos = Vector.scharTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testScharThrees(self): "Test scharThrees function" - threes = Series.scharThrees(6) + threes = Vector.scharThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ##################################################### ### Test functions that take arrays of type UBYTE ### def testUcharLength(self): "Test ucharLength function" - self.assertEquals(Series.ucharLength([5, 12, 0]), 13) + self.assertEquals(Vector.ucharLength([5, 12, 0]), 13) def testUcharLengthBad(self): "Test ucharLength function for wrong size" - self.assertRaises(TypeError, Series.ucharLength, [5, 12]) + self.assertRaises(TypeError, Vector.ucharLength, [5, 12]) def testUcharProd(self): "Test ucharProd function" - self.assertEquals(Series.ucharProd([1,2,3,4]), 24) + self.assertEquals(Vector.ucharProd([1,2,3,4]), 24) def testUcharProdNonContainer(self): "Test ucharProd function with None" - self.assertRaises(TypeError, Series.ucharProd, None) + self.assertRaises(TypeError, Vector.ucharProd, None) def testUcharSum(self): "Test ucharSum function" - self.assertEquals(Series.ucharSum([5,6,7,8]), 26) + self.assertEquals(Vector.ucharSum([5,6,7,8]), 26) def testUcharReverse(self): "Test ucharReverse function" vector = N.array([1,2,4],'B') - Series.ucharReverse(vector) + Vector.ucharReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testUcharOnes(self): "Test ucharOnes function" myArray = N.zeros(5,'B') - Series.ucharOnes(myArray) + Vector.ucharOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testUcharZeros(self): "Test ucharZeros function" myArray = N.ones(5,'B') - Series.ucharZeros(myArray) + Vector.ucharZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testUcharEOSplit(self): "Test ucharEOSplit function" - even, odd = Series.ucharEOSplit([1,2,3]) + even, odd = Vector.ucharEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testUcharTwos(self): "Test ucharTwos function" - twos = Series.ucharTwos(5) + twos = Vector.ucharTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testUcharThrees(self): "Test ucharThrees function" - threes = Series.ucharThrees(6) + threes = Vector.ucharThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ##################################################### ### Test functions that take arrays of type SHORT ### def testShortLength(self): "Test shortLength function" - self.assertEquals(Series.shortLength([5, 12, 0]), 13) + self.assertEquals(Vector.shortLength([5, 12, 0]), 13) def testShortLengthBad(self): "Test shortLength function for wrong size" - self.assertRaises(TypeError, Series.shortLength, [5, 12]) + self.assertRaises(TypeError, Vector.shortLength, [5, 12]) def testShortProd(self): "Test shortProd function" - self.assertEquals(Series.shortProd([1,2,3,4]), 24) + self.assertEquals(Vector.shortProd([1,2,3,4]), 24) def testShortProdNonContainer(self): "Test shortProd function with None" - self.assertRaises(TypeError, Series.shortProd, None) + self.assertRaises(TypeError, Vector.shortProd, None) def testShortSum(self): "Test shortSum function" - self.assertEquals(Series.shortSum([-5,6,-7,8]), 2) + self.assertEquals(Vector.shortSum([-5,6,-7,8]), 2) def testShortReverse(self): "Test shortReverse function" vector = N.array([1,2,4],'h') - Series.shortReverse(vector) + Vector.shortReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testShortOnes(self): "Test shortOnes function" myArray = N.zeros(5,'h') - Series.shortOnes(myArray) + Vector.shortOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testShortZeros(self): "Test shortZeros function" myArray = N.ones(5,'h') - Series.shortZeros(myArray) + Vector.shortZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testShortEOSplit(self): "Test shortEOSplit function" - even, odd = Series.shortEOSplit([1,2,3]) + even, odd = Vector.shortEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testShortTwos(self): "Test shortTwos function" - twos = Series.shortTwos(5) + twos = Vector.shortTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testShortThrees(self): "Test shortThrees function" - threes = Series.shortThrees(6) + threes = Vector.shortThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ###################################################### ### Test functions that take arrays of type USHORT ### def testUshortLength(self): "Test ushortLength function" - self.assertEquals(Series.ushortLength([5, 12, 0]), 13) + self.assertEquals(Vector.ushortLength([5, 12, 0]), 13) def testUshortLengthBad(self): "Test ushortLength function for wrong size" - self.assertRaises(TypeError, Series.ushortLength, [5, 12]) + self.assertRaises(TypeError, Vector.ushortLength, [5, 12]) def testUshortProd(self): "Test ushortProd function" - self.assertEquals(Series.ushortProd([1,2,3,4]), 24) + self.assertEquals(Vector.ushortProd([1,2,3,4]), 24) def testUshortProdNonContainer(self): "Test ushortProd function with None" - self.assertRaises(TypeError, Series.ushortProd, None) + self.assertRaises(TypeError, Vector.ushortProd, None) def testUshortSum(self): "Test ushortSum function" - self.assertEquals(Series.ushortSum([5,6,7,8]), 26) + self.assertEquals(Vector.ushortSum([5,6,7,8]), 26) def testUshortReverse(self): "Test ushortReverse function" vector = N.array([1,2,4],'H') - Series.ushortReverse(vector) + Vector.ushortReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testUshortOnes(self): "Test ushortOnes function" myArray = N.zeros(5,'H') - Series.ushortOnes(myArray) + Vector.ushortOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testUshortZeros(self): "Test ushortZeros function" myArray = N.ones(5,'H') - Series.ushortZeros(myArray) + Vector.ushortZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testUshortEOSplit(self): "Test ushortEOSplit function" - even, odd = Series.ushortEOSplit([1,2,3]) + even, odd = Vector.ushortEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testUshortTwos(self): "Test ushortTwos function" - twos = Series.ushortTwos(5) + twos = Vector.ushortTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testUshortThrees(self): "Test ushortThrees function" - threes = Series.ushortThrees(6) + threes = Vector.ushortThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ################################################### ### Test functions that take arrays of type INT ### def testIntLength(self): "Test intLength function" - self.assertEquals(Series.intLength([5, 12, 0]), 13) + self.assertEquals(Vector.intLength([5, 12, 0]), 13) def testIntLengthBad(self): "Test intLength function for wrong size" - self.assertRaises(TypeError, Series.intLength, [5, 12]) + self.assertRaises(TypeError, Vector.intLength, [5, 12]) def testIntProd(self): "Test intProd function" - self.assertEquals(Series.intProd([1,2,3,4]), 24) + self.assertEquals(Vector.intProd([1,2,3,4]), 24) def testIntProdNonContainer(self): "Test intProd function with None" - self.assertRaises(TypeError, Series.intProd, None) + self.assertRaises(TypeError, Vector.intProd, None) def testIntSum(self): "Test intSum function" - self.assertEquals(Series.intSum([-5,6,-7,8]), 2) + self.assertEquals(Vector.intSum([-5,6,-7,8]), 2) def testIntOnes(self): "Test intOnes function" myArray = N.zeros(5,'i') - Series.intOnes(myArray) + Vector.intOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testIntReverse(self): "Test intReverse function" vector = N.array([1,2,4],'i') - Series.intReverse(vector) + Vector.intReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testIntZeros(self): "Test intZeros function" myArray = N.ones(5,'i') - Series.intZeros(myArray) + Vector.intZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testIntEOSplit(self): "Test intEOSplit function" - even, odd = Series.intEOSplit([1,2,3]) + even, odd = Vector.intEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testIntTwos(self): "Test intTwos function" - twos = Series.intTwos(5) + twos = Vector.intTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testIntThrees(self): "Test intThrees function" - threes = Series.intThrees(6) + threes = Vector.intThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) #################################################### ### Test functions that take arrays of type UINT ### def testUintLength(self): "Test uintLength function" - self.assertEquals(Series.uintLength([5, 12, 0]), 13) + self.assertEquals(Vector.uintLength([5, 12, 0]), 13) def testUintLengthBad(self): "Test uintLength function for wrong size" - self.assertRaises(TypeError, Series.uintLength, [5, 12]) + self.assertRaises(TypeError, Vector.uintLength, [5, 12]) def testUintProd(self): "Test uintProd function" - self.assertEquals(Series.uintProd([1,2,3,4]), 24) + self.assertEquals(Vector.uintProd([1,2,3,4]), 24) def testUintProdNonContainer(self): "Test uintProd function with None" - self.assertRaises(TypeError, Series.uintProd, None) + self.assertRaises(TypeError, Vector.uintProd, None) def testUintSum(self): "Test uintSum function" - self.assertEquals(Series.uintSum([5,6,7,8]), 26) + self.assertEquals(Vector.uintSum([5,6,7,8]), 26) def testUintReverse(self): "Test uintReverse function" vector = N.array([1,2,4],'I') - Series.uintReverse(vector) + Vector.uintReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testUintOnes(self): "Test uintOnes function" myArray = N.zeros(5,'I') - Series.uintOnes(myArray) + Vector.uintOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testUintZeros(self): "Test uintZeros function" myArray = N.ones(5,'I') - Series.uintZeros(myArray) + Vector.uintZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testUintEOSplit(self): "Test uintEOSplit function" - even, odd = Series.uintEOSplit([1,2,3]) + even, odd = Vector.uintEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testUintTwos(self): "Test uintTwos function" - twos = Series.uintTwos(5) + twos = Vector.uintTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testUintThrees(self): "Test uintThrees function" - threes = Series.uintThrees(6) + threes = Vector.uintThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) #################################################### ### Test functions that take arrays of type LONG ### def testLongLength(self): "Test longLength function" - self.assertEquals(Series.longLength([5, 12, 0]), 13) + self.assertEquals(Vector.longLength([5, 12, 0]), 13) def testLongLengthBad(self): "Test longLength function for wrong size" - self.assertRaises(TypeError, Series.longLength, [5, 12]) + self.assertRaises(TypeError, Vector.longLength, [5, 12]) def testLongProd(self): "Test longProd function" - self.assertEquals(Series.longProd([1,2,3,4]), 24) + self.assertEquals(Vector.longProd([1,2,3,4]), 24) def testLongProdNonContainer(self): "Test longProd function with None" - self.assertRaises(TypeError, Series.longProd, None) + self.assertRaises(TypeError, Vector.longProd, None) def testLongSum(self): "Test longSum function" - self.assertEquals(Series.longSum([-5,6,-7,8]), 2) + self.assertEquals(Vector.longSum([-5,6,-7,8]), 2) def testLongReverse(self): "Test longReverse function" vector = N.array([1,2,4],'l') - Series.longReverse(vector) + Vector.longReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testLongOnes(self): "Test longOnes function" myArray = N.zeros(5,'l') - Series.longOnes(myArray) + Vector.longOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testLongZeros(self): "Test longZeros function" myArray = N.ones(5,'l') - Series.longZeros(myArray) + Vector.longZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testLongEOSplit(self): "Test longEOSplit function" - even, odd = Series.longEOSplit([1,2,3]) + even, odd = Vector.longEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testLongTwos(self): "Test longTwos function" - twos = Series.longTwos(5) + twos = Vector.longTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testLongThrees(self): "Test longThrees function" - threes = Series.longThrees(6) + threes = Vector.longThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ##################################################### ### Test functions that take arrays of type ULONG ### def testUlongLength(self): "Test ulongLength function" - self.assertEquals(Series.ulongLength([5, 12, 0]), 13) + self.assertEquals(Vector.ulongLength([5, 12, 0]), 13) def testUlongLengthBad(self): "Test ulongLength function for wrong size" - self.assertRaises(TypeError, Series.ulongLength, [5, 12]) + self.assertRaises(TypeError, Vector.ulongLength, [5, 12]) def testUlongProd(self): "Test ulongProd function" - self.assertEquals(Series.ulongProd([1,2,3,4]), 24) + self.assertEquals(Vector.ulongProd([1,2,3,4]), 24) def testUlongProdNonContainer(self): "Test ulongProd function with None" - self.assertRaises(TypeError, Series.ulongProd, None) + self.assertRaises(TypeError, Vector.ulongProd, None) def testUlongSum(self): "Test ulongSum function" - self.assertEquals(Series.ulongSum([5,6,7,8]), 26) + self.assertEquals(Vector.ulongSum([5,6,7,8]), 26) def testUlongReverse(self): "Test ulongReverse function" vector = N.array([1,2,4],'L') - Series.ulongReverse(vector) + Vector.ulongReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testUlongOnes(self): "Test ulongOnes function" myArray = N.zeros(5,'L') - Series.ulongOnes(myArray) + Vector.ulongOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testUlongZeros(self): "Test ulongZeros function" myArray = N.ones(5,'L') - Series.ulongZeros(myArray) + Vector.ulongZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testUlongEOSplit(self): "Test ulongEOSplit function" - even, odd = Series.ulongEOSplit([1,2,3]) + even, odd = Vector.ulongEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testUlongTwos(self): "Test ulongTwos function" - twos = Series.ulongTwos(5) + twos = Vector.ulongTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testUlongThrees(self): "Test ulongThrees function" - threes = Series.ulongThrees(6) + threes = Vector.ulongThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ######################################################## ### Test functions that take arrays of type LONGLONG ### def testLongLongLength(self): "Test longLongLength function" - self.assertEquals(Series.longLongLength([5, 12, 0]), 13) + self.assertEquals(Vector.longLongLength([5, 12, 0]), 13) def testLongLongLengthBad(self): "Test longLongLength function for wrong size" - self.assertRaises(TypeError, Series.longLongLength, [5, 12]) + self.assertRaises(TypeError, Vector.longLongLength, [5, 12]) def testLongLongProd(self): "Test longLongProd function" - self.assertEquals(Series.longLongProd([1,2,3,4]), 24) + self.assertEquals(Vector.longLongProd([1,2,3,4]), 24) def testLongLongProdNonContainer(self): "Test longLongProd function with None" - self.assertRaises(TypeError, Series.longLongProd, None) + self.assertRaises(TypeError, Vector.longLongProd, None) def testLongLongSum(self): "Test longLongSum function" - self.assertEquals(Series.longLongSum([-5,6,-7,8]), 2) + self.assertEquals(Vector.longLongSum([-5,6,-7,8]), 2) def testLongLongReverse(self): "Test longLongReverse function" vector = N.array([1,2,4],'q') - Series.longLongReverse(vector) + Vector.longLongReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testLongLongOnes(self): "Test longLongOnes function" myArray = N.zeros(5,'q') - Series.longLongOnes(myArray) + Vector.longLongOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testLongLongZeros(self): "Test longLongZeros function" myArray = N.ones(5,'q') - Series.longLongZeros(myArray) + Vector.longLongZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testLongLongEOSplit(self): "Test longLongEOSplit function" - even, odd = Series.longLongEOSplit([1,2,3]) + even, odd = Vector.longLongEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testLongLongTwos(self): "Test longLongTwos function" - twos = Series.longLongTwos(5) + twos = Vector.longLongTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testLongLongThrees(self): "Test longLongThrees function" - threes = Series.longLongThrees(6) + threes = Vector.longLongThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ######################################################### ### Test functions that take arrays of type ULONGLONG ### def testUlongLongLength(self): "Test ulongLongLength function" - self.assertEquals(Series.ulongLongLength([5, 12, 0]), 13) + self.assertEquals(Vector.ulongLongLength([5, 12, 0]), 13) def testUlongLongLengthBad(self): "Test ulongLongLength function for wrong size" - self.assertRaises(TypeError, Series.ulongLongLength, [5, 12]) + self.assertRaises(TypeError, Vector.ulongLongLength, [5, 12]) def testUlonglongProd(self): "Test ulongLongProd function" - self.assertEquals(Series.ulongLongProd([1,2,3,4]), 24) + self.assertEquals(Vector.ulongLongProd([1,2,3,4]), 24) def testUlongLongProdNonContainer(self): "Test ulongLongProd function with None" - self.assertRaises(TypeError, Series.ulongLongProd, None) + self.assertRaises(TypeError, Vector.ulongLongProd, None) def testUlongLongSum(self): "Test ulongLongSum function" - self.assertEquals(Series.ulongLongSum([5,6,7,8]), 26) + self.assertEquals(Vector.ulongLongSum([5,6,7,8]), 26) def testUlongLongReverse(self): "Test ulongLongReverse function" vector = N.array([1,2,4],'Q') - Series.ulongLongReverse(vector) + Vector.ulongLongReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testUlongLongOnes(self): "Test ulongLongOnes function" myArray = N.zeros(5,'Q') - Series.ulongLongOnes(myArray) + Vector.ulongLongOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1])) def testUlongLongZeros(self): "Test ulongLongZeros function" myArray = N.ones(5,'Q') - Series.ulongLongZeros(myArray) + Vector.ulongLongZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testUlongLongEOSplit(self): "Test ulongLongEOSplit function" - even, odd = Series.ulongLongEOSplit([1,2,3]) + even, odd = Vector.ulongLongEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testUlongLongTwos(self): "Test ulongLongTwos function" - twos = Series.ulongLongTwos(5) + twos = Vector.ulongLongTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testUlongLongThrees(self): "Test ulongLongThrees function" - threes = Series.ulongLongThrees(6) + threes = Vector.ulongLongThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ##################################################### ### Test functions that take arrays of type FLOAT ### def testFloatLength(self): "Test floatLength function" - self.assertEquals(Series.floatLength([5, 12, 0]), 13) + self.assertEquals(Vector.floatLength([5, 12, 0]), 13) def testFloatLengthBad(self): "Test floatLength function for wrong size" - self.assertRaises(TypeError, Series.floatLength, [5, 12]) + self.assertRaises(TypeError, Vector.floatLength, [5, 12]) def testFloatProd(self): "Test floatProd function (to 5 decimal places)" - self.assertAlmostEquals(Series.floatProd((1,2.718,3,4)), 32.616, 5) + self.assertAlmostEquals(Vector.floatProd((1,2.718,3,4)), 32.616, 5) def testFloatProdBadContainer(self): "Test floatProd function with an invalid list" - self.assertRaises(BadListError, Series.floatProd, [3.14, "pi"]) + self.assertRaises(BadListError, Vector.floatProd, [3.14, "pi"]) def testFloatSum(self): "Test floatSum function" - self.assertEquals(Series.floatSum([-5,6,-7,8]), 2) + self.assertEquals(Vector.floatSum([-5,6,-7,8]), 2) def testFloatReverse(self): "Test floatReverse function" vector = N.array([1,2,4],'f') - Series.floatReverse(vector) + Vector.floatReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testFloatOnes(self): "Test floatOnes function" myArray = N.zeros(5,'f') - Series.floatOnes(myArray) + Vector.floatOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1.,1.,1.,1.,1.])) def testFloatOnesNonArray(self): "Test floatOnes function with a list" - self.assertRaises(TypeError, Series.floatOnes, [True, 0, 2.718, "pi"]) + self.assertRaises(TypeError, Vector.floatOnes, [True, 0, 2.718, "pi"]) + + def testFloatZeros(self): + "Test floatZeros function" + myArray = N.ones(5,'f') + Vector.floatZeros(myArray) + N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) + + def testFloatEOSplit(self): + "Test floatEOSplit function" + even, odd = Vector.floatEOSplit([1,2,3]) + self.assertEquals((even == [1,0,3]).all(), True) + self.assertEquals((odd == [0,2,0]).all(), True) + + def testFloatTwos(self): + "Test floatTwos function" + twos = Vector.floatTwos(5) + self.assertEquals((twos == [2,2,2,2,2]).all(), True) + + def testFloatThrees(self): + "Test floatThrees function" + threes = Vector.floatThrees(6) + self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ###################################################### ### Test functions that take arrays of type DOUBLE ### def testDoubleLength(self): "Test doubleLength function" - self.assertEquals(Series.doubleLength([5, 12, 0]), 13) + self.assertEquals(Vector.doubleLength([5, 12, 0]), 13) def testDoubleLengthBad(self): "Test doubleLength function for wrong size" - self.assertRaises(TypeError, Series.doubleLength, [5, 12]) + self.assertRaises(TypeError, Vector.doubleLength, [5, 12]) def testDoubleProd(self): "Test doubleProd function" - self.assertEquals(Series.doubleProd((1,2.718,3,4)), 32.616) + self.assertEquals(Vector.doubleProd((1,2.718,3,4)), 32.616) def testDoubleProdBadContainer(self): "Test doubleProd function with an invalid list" - self.assertRaises(BadListError, Series.doubleProd, [3.14, "pi"]) + self.assertRaises(BadListError, Vector.doubleProd, [3.14, "pi"]) def testDoubleSum(self): "Test doubleSum function" - self.assertEquals(Series.doubleSum([-5,6,-7,8]), 2) + self.assertEquals(Vector.doubleSum([-5,6,-7,8]), 2) def testDoubleReverse(self): "Test doubleReverse function" vector = N.array([1,2,4],'d') - Series.doubleReverse(vector) + Vector.doubleReverse(vector) self.assertEquals((vector == [4,2,1]).all(), True) def testDoubleOnes(self): "Test doubleOnes function" myArray = N.zeros(5,'d') - Series.doubleOnes(myArray) + Vector.doubleOnes(myArray) N.testing.assert_array_equal(myArray, N.array([1.,1.,1.,1.,1.])) def testDoubleOnesNonArray(self): "Test doubleOnes function with a list" - self.assertRaises(TypeError, Series.doubleOnes, [True, 0, 2.718, "pi"]) + self.assertRaises(TypeError, Vector.doubleOnes, [True, 0, 2.718, "pi"]) def testDoubleZeros(self): "Test doubleZeros function" myArray = N.ones(5,'d') - Series.doubleZeros(myArray) + Vector.doubleZeros(myArray) N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0])) def testDoubleEOSplit(self): "Test doubleEOSplit function" - even, odd = Series.doubleEOSplit([1,2,3]) + even, odd = Vector.doubleEOSplit([1,2,3]) self.assertEquals((even == [1,0,3]).all(), True) self.assertEquals((odd == [0,2,0]).all(), True) def testDoubleTwos(self): "Test doubleTwos function" - twos = Series.doubleTwos(5) + twos = Vector.doubleTwos(5) self.assertEquals((twos == [2,2,2,2,2]).all(), True) def testDoubleThrees(self): "Test doubleThrees function" - threes = Series.doubleThrees(6) + threes = Vector.doubleThrees(6) self.assertEquals((threes == [3,3,3,3,3,3]).all(), True) ###################################################################### @@ -687,10 +709,10 @@ if __name__ == "__main__": # Build the test suite suite = unittest.TestSuite() - suite.addTest(unittest.makeSuite(SeriesTestCase)) + suite.addTest(unittest.makeSuite(VectorTestCase)) # Execute the test suite - print "Testing 1D Functions of Module Series" + print "Testing 1D Functions of Module Vector" print "NumPy version", N.__version__ print result = unittest.TextTestRunner(verbosity=2).run(suite) |