Gecko [ goons4good.org ]

Name	Size	Permission	Date
test__datasource.py	9.91 KB	-rw-r--r--	2013-04-07 01:04
test__datasource.pyc	15.95 KB	-rw-r--r--	2018-04-10 19:40
test__datasource.pyo	15.95 KB	-rw-r--r--	2018-04-10 19:40
test__iotools.py	13.12 KB	-rw-r--r--	2013-04-07 01:04
test__iotools.pyc	14.4 KB	-rw-r--r--	2018-04-10 19:40
test__iotools.pyo	14.4 KB	-rw-r--r--	2018-04-10 19:40
test_arraypad.py	23.84 KB	-rw-r--r--	2013-04-07 01:04
test_arraypad.pyc	29.81 KB	-rw-r--r--	2018-04-10 19:40
test_arraypad.pyo	29.81 KB	-rw-r--r--	2018-04-10 19:40
test_arraysetops.py	7.52 KB	-rw-r--r--	2013-04-07 01:04
test_arraysetops.pyc	7.88 KB	-rw-r--r--	2018-04-10 19:40
test_arraysetops.pyo	7.88 KB	-rw-r--r--	2018-04-10 19:40
test_arrayterator.py	1.4 KB	-rw-r--r--	2013-04-07 01:04
test_arrayterator.pyc	1.98 KB	-rw-r--r--	2018-04-10 19:40
test_arrayterator.pyo	1.98 KB	-rw-r--r--	2018-04-10 19:40
test_financial.py	5.32 KB	-rw-r--r--	2013-04-07 01:04
test_financial.pyc	6.21 KB	-rw-r--r--	2018-04-10 19:40
test_financial.pyo	6.21 KB	-rw-r--r--	2018-04-10 19:40
test_format.py	25.04 KB	-rw-r--r--	2013-04-07 01:04
test_format.pyc	25 KB	-rw-r--r--	2018-04-10 19:40
test_format.pyo	25 KB	-rw-r--r--	2018-04-10 19:40
test_function_base.py	50.27 KB	-rw-r--r--	2013-04-07 01:04
test_function_base.pyc	72.44 KB	-rw-r--r--	2018-04-10 19:40
test_function_base.pyo	72.44 KB	-rw-r--r--	2018-04-10 19:40
test_index_tricks.py	8.98 KB	-rw-r--r--	2013-04-07 01:04
test_index_tricks.pyc	12.25 KB	-rw-r--r--	2018-04-10 19:40
test_index_tricks.pyo	12.25 KB	-rw-r--r--	2018-04-10 19:40
test_io.py	59.81 KB	-rw-r--r--	2013-04-07 01:04
test_io.pyc	73.17 KB	-rw-r--r--	2018-04-10 19:40
test_io.pyo	73.17 KB	-rw-r--r--	2018-04-10 19:40
test_polynomial.py	4.41 KB	-rw-r--r--	2013-04-07 01:04
test_polynomial.pyc	6.1 KB	-rw-r--r--	2018-04-10 19:40
test_polynomial.pyo	6.1 KB	-rw-r--r--	2018-04-10 19:40
test_recfunctions.py	27.93 KB	-rw-r--r--	2013-04-07 01:04
test_recfunctions.pyc	35.45 KB	-rw-r--r--	2018-04-10 19:40
test_recfunctions.pyo	35.45 KB	-rw-r--r--	2018-04-10 19:40
test_regression.py	8.02 KB	-rw-r--r--	2013-04-07 01:04
test_regression.pyc	13.26 KB	-rw-r--r--	2018-04-10 19:40
test_regression.pyo	13.26 KB	-rw-r--r--	2018-04-10 19:40
test_shape_base.py	9.92 KB	-rw-r--r--	2013-04-07 01:04
test_shape_base.pyc	15.89 KB	-rw-r--r--	2018-04-10 19:40
test_shape_base.pyo	15.89 KB	-rw-r--r--	2018-04-10 19:40
test_stride_tricks.py	6.79 KB	-rw-r--r--	2013-04-07 01:04
test_stride_tricks.pyc	8.92 KB	-rw-r--r--	2018-04-10 19:40
test_stride_tricks.pyo	8.92 KB	-rw-r--r--	2018-04-10 19:40
test_twodim_base.py	11.38 KB	-rw-r--r--	2013-04-07 01:04
test_twodim_base.pyc	15.93 KB	-rw-r--r--	2018-04-10 19:40
test_twodim_base.pyo	15.93 KB	-rw-r--r--	2018-04-10 19:40
test_type_check.py	10.33 KB	-rw-r--r--	2013-04-07 01:04
test_type_check.pyc	18.71 KB	-rw-r--r--	2018-04-10 19:40
test_type_check.pyo	18.71 KB	-rw-r--r--	2018-04-10 19:40
test_ufunclike.py	1.88 KB	-rw-r--r--	2013-04-07 01:04
test_ufunclike.pyc	3.33 KB	-rw-r--r--	2018-04-10 19:40
test_ufunclike.pyo	3.33 KB	-rw-r--r--	2018-04-10 19:40
test_utils.py	920 B	-rw-r--r--	2013-04-07 01:04
test_utils.pyc	2.13 KB	-rw-r--r--	2018-04-10 19:40
test_utils.pyo	2.13 KB	-rw-r--r--	2018-04-10 19:40

Rename

from numpy.testing import *
from numpy.lib import *
from numpy.core import *
from numpy import matrix, asmatrix

class TestApplyAlongAxis(TestCase):
    def test_simple(self):
        a = ones((20,10),'d')
        assert_array_equal(apply_along_axis(len,0,a),len(a)*ones(shape(a)[1]))

def test_simple101(self,level=11):
        a = ones((10,101),'d')
        assert_array_equal(apply_along_axis(len,0,a),len(a)*ones(shape(a)[1]))

def test_3d(self):
        a = arange(27).reshape((3,3,3))
        assert_array_equal(apply_along_axis(sum,0,a),
                           [[27,30,33],[36,39,42],[45,48,51]])

class TestApplyOverAxes(TestCase):
    def test_simple(self):
        a = arange(24).reshape(2,3,4)
        aoa_a = apply_over_axes(sum, a, [0,2])
        assert_array_equal(aoa_a, array([[[60],[92],[124]]]))

class TestArraySplit(TestCase):
    def test_integer_0_split(self):
        a = arange(10)
        try:
            res = array_split(a,0)
            assert_(0) # it should have thrown a value error
        except ValueError:
            pass

def test_integer_split(self):
        a = arange(10)
        res = array_split(a,1)
        desired = [arange(10)]
        compare_results(res,desired)

res = array_split(a,2)
        desired = [arange(5),arange(5,10)]
        compare_results(res,desired)

res = array_split(a,3)
        desired = [arange(4),arange(4,7),arange(7,10)]
        compare_results(res,desired)

res = array_split(a,4)
        desired = [arange(3),arange(3,6),arange(6,8),arange(8,10)]
        compare_results(res,desired)

res = array_split(a,5)
        desired = [arange(2),arange(2,4),arange(4,6),arange(6,8),arange(8,10)]
        compare_results(res,desired)

res = array_split(a,6)
        desired = [arange(2),arange(2,4),arange(4,6),arange(6,8),arange(8,9),
                   arange(9,10)]
        compare_results(res,desired)

res = array_split(a,7)
        desired = [arange(2),arange(2,4),arange(4,6),arange(6,7),arange(7,8),
                   arange(8,9), arange(9,10)]
        compare_results(res,desired)

res = array_split(a,8)
        desired = [arange(2),arange(2,4),arange(4,5),arange(5,6),arange(6,7),
                   arange(7,8), arange(8,9), arange(9,10)]
        compare_results(res,desired)

res = array_split(a,9)
        desired = [arange(2),arange(2,3),arange(3,4),arange(4,5),arange(5,6),
                   arange(6,7), arange(7,8), arange(8,9), arange(9,10)]
        compare_results(res,desired)

res = array_split(a,10)
        desired = [arange(1),arange(1,2),arange(2,3),arange(3,4),
                   arange(4,5),arange(5,6), arange(6,7), arange(7,8),
                   arange(8,9), arange(9,10)]
        compare_results(res,desired)

res = array_split(a,11)
        desired = [arange(1),arange(1,2),arange(2,3),arange(3,4),
                   arange(4,5),arange(5,6), arange(6,7), arange(7,8),
                   arange(8,9), arange(9,10),array([])]
        compare_results(res,desired)

def test_integer_split_2D_rows(self):
        a = array([arange(10),arange(10)])
        res = array_split(a,3,axis=0)
        desired = [array([arange(10)]),array([arange(10)]),array([])]
        compare_results(res,desired)

def test_integer_split_2D_cols(self):
        a = array([arange(10),arange(10)])
        res = array_split(a,3,axis=-1)
        desired = [array([arange(4),arange(4)]),
                   array([arange(4,7),arange(4,7)]),
                   array([arange(7,10),arange(7,10)])]
        compare_results(res,desired)

def test_integer_split_2D_default(self):
        """ This will fail if we change default axis
        """
        a = array([arange(10),arange(10)])
        res = array_split(a,3)
        desired = [array([arange(10)]),array([arange(10)]),array([])]
        compare_results(res,desired)
    #perhaps should check higher dimensions

def test_index_split_simple(self):
        a = arange(10)
        indices = [1,5,7]
        res = array_split(a,indices,axis=-1)
        desired = [arange(0,1),arange(1,5),arange(5,7),arange(7,10)]
        compare_results(res,desired)

def test_index_split_low_bound(self):
        a = arange(10)
        indices = [0,5,7]
        res = array_split(a,indices,axis=-1)
        desired = [array([]),arange(0,5),arange(5,7),arange(7,10)]
        compare_results(res,desired)

def test_index_split_high_bound(self):
        a = arange(10)
        indices = [0,5,7,10,12]
        res = array_split(a,indices,axis=-1)
        desired = [array([]),arange(0,5),arange(5,7),arange(7,10),
                   array([]),array([])]
        compare_results(res,desired)

class TestSplit(TestCase):
    """* This function is essentially the same as array_split,
         except that it test if splitting will result in an
         equal split.  Only test for this case.
    *"""
    def test_equal_split(self):
        a = arange(10)
        res = split(a,2)
        desired = [arange(5),arange(5,10)]
        compare_results(res,desired)

def test_unequal_split(self):
        a = arange(10)
        try:
            res = split(a,3)
            assert_(0) # should raise an error
        except ValueError:
            pass

class TestDstack(TestCase):
    def test_0D_array(self):
        a = array(1); b = array(2);
        res=dstack([a,b])
        desired = array([[[1,2]]])
        assert_array_equal(res,desired)

def test_1D_array(self):
        a = array([1]); b = array([2]);
        res=dstack([a,b])
        desired = array([[[1,2]]])
        assert_array_equal(res,desired)

def test_2D_array(self):
        a = array([[1],[2]]); b = array([[1],[2]]);
        res=dstack([a,b])
        desired = array([[[1,1]],[[2,2,]]])
        assert_array_equal(res,desired)

def test_2D_array2(self):
        a = array([1,2]); b = array([1,2]);
        res=dstack([a,b])
        desired = array([[[1,1],[2,2]]])
        assert_array_equal(res,desired)

""" array_split has more comprehensive test of splitting.
    only do simple test on hsplit, vsplit, and dsplit
"""
class TestHsplit(TestCase):
    """ only testing for integer splits.
    """
    def test_0D_array(self):
        a= array(1)
        try:
            hsplit(a,2)
            assert_(0)
        except ValueError:
            pass

def test_1D_array(self):
        a= array([1,2,3,4])
        res = hsplit(a,2)
        desired = [array([1,2]),array([3,4])]
        compare_results(res,desired)

def test_2D_array(self):
        a= array([[1,2,3,4],
                  [1,2,3,4]])
        res = hsplit(a,2)
        desired = [array([[1,2],[1,2]]),array([[3,4],[3,4]])]
        compare_results(res,desired)

class TestVsplit(TestCase):
    """ only testing for integer splits.
    """
    def test_1D_array(self):
        a= array([1,2,3,4])
        try:
            vsplit(a,2)
            assert_(0)
        except ValueError:
            pass

def test_2D_array(self):
        a= array([[1,2,3,4],
                  [1,2,3,4]])
        res = vsplit(a,2)
        desired = [array([[1,2,3,4]]),array([[1,2,3,4]])]
        compare_results(res,desired)

class TestDsplit(TestCase):
    """ only testing for integer splits.
    """
    def test_2D_array(self):
        a= array([[1,2,3,4],
                  [1,2,3,4]])
        try:
            dsplit(a,2)
            assert_(0)
        except ValueError:
            pass

def test_3D_array(self):
        a= array([[[1,2,3,4],
                   [1,2,3,4]],
                  [[1,2,3,4],
                   [1,2,3,4]]])
        res = dsplit(a,2)
        desired = [array([[[1,2],[1,2]],[[1,2],[1,2]]]),
                   array([[[3,4],[3,4]],[[3,4],[3,4]]])]
        compare_results(res,desired)

class TestSqueeze(TestCase):
    def test_basic(self):
        a = rand(20,10,10,1,1)
        b = rand(20,1,10,1,20)
        c = rand(1,1,20,10)
        assert_array_equal(squeeze(a),reshape(a,(20,10,10)))
        assert_array_equal(squeeze(b),reshape(b,(20,10,20)))
        assert_array_equal(squeeze(c),reshape(c,(20,10)))

# Squeezing to 0-dim should still give an ndarray
        a = [[[1.5]]]
        res = squeeze(a)
        assert_equal(res, 1.5)
        assert_equal(res.ndim, 0)
        assert_equal(type(res), ndarray)

class TestKron(TestCase):
    def test_return_type(self):
        a = ones([2,2])
        m = asmatrix(a)
        assert_equal(type(kron(a,a)), ndarray)
        assert_equal(type(kron(m,m)), matrix)
        assert_equal(type(kron(a,m)), matrix)
        assert_equal(type(kron(m,a)), matrix)
        class myarray(ndarray):
            __array_priority__ = 0.0
        ma = myarray(a.shape, a.dtype, a.data)
        assert_equal(type(kron(a,a)), ndarray)
        assert_equal(type(kron(ma,ma)), myarray)
        assert_equal(type(kron(a,ma)), ndarray)
        assert_equal(type(kron(ma,a)), myarray)

class TestTile(TestCase):
    def test_basic(self):
        a = array([0,1,2])
        b = [[1,2],[3,4]]
        assert_equal(tile(a,2), [0,1,2,0,1,2])
        assert_equal(tile(a,(2,2)), [[0,1,2,0,1,2],[0,1,2,0,1,2]])
        assert_equal(tile(a,(1,2)), [[0,1,2,0,1,2]])
        assert_equal(tile(b, 2), [[1,2,1,2],[3,4,3,4]])
        assert_equal(tile(b,(2,1)),[[1,2],[3,4],[1,2],[3,4]])
        assert_equal(tile(b,(2,2)),[[1,2,1,2],[3,4,3,4],
                                    [1,2,1,2],[3,4,3,4]])

def test_empty(self):
        a = array([[[]]])
        d = tile(a,(3,2,5)).shape
        assert_equal(d,(3,2,0))

def test_kroncompare(self):
        import numpy.random as nr
        reps=[(2,),(1,2),(2,1),(2,2),(2,3,2),(3,2)]
        shape=[(3,),(2,3),(3,4,3),(3,2,3),(4,3,2,4),(2,2)]
        for s in shape:
            b = nr.randint(0,10,size=s)
            for r in reps:
                a = ones(r, b.dtype)
                large = tile(b, r)
                klarge = kron(a, b)
                assert_equal(large, klarge)

# Utility
def compare_results(res,desired):
    for i in range(len(desired)):
        assert_array_equal(res[i],desired[i])

if __name__ == "__main__":
    run_module_suite()