Commits

Andrew Dalke  committed 4e6e173

Migrated numpy's test_function_base.py to use pypy's test framework.

The goal here is to have something to help bootstrap the
core functions, by having code which is not dependent on
'numpy.testing'.

  • Participants
  • Parent commits b10a89e
  • Branches numpy-andrew-tests

Comments (0)

Files changed (1)

File pypy/module/micronumpy/test/test_function_base.py

+# Imported from numpy-1.6.2/numpy/lib/tests/test_function_base.py
+import warnings
+
+import operator
+
+from pypy.module.micronumpy.test.test_base import BaseNumpyAppTest
+
+### These helper functions are just good enough to get the tests to pass.
+
+def assert_raises(exc_type, callable_, *args, **kwargs):
+    try:
+        callable_(*args, **kwargs)
+    except exc_type:
+        return
+    raise AssertionError("Should have raised %r" % (exc_type,))
+
+
+def assert_array_compare(comparison, x, y, err_msg='', verbose=True,
+                         header=''):
+    val = comparison(x, y)
+    reduced = val.ravel()
+    cond = reduced.all()
+    #reduced = reduced.tolist()
+    assert cond
+
+def assert_array_equal(x, y, err_msg="", verbose=True):
+    if isinstance(x, list) and isinstance(y, list):
+        for a, b in zip(x, y):
+            assert_array_equal(a, b, err_msg, verbose)
+    else:
+        if not (x == y).all():
+            raise AssertionError('Arrays are not equal')
+
+def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
+    z = abs(x.ravel() - y.ravel()) * (10**decimal)
+    for term in z:
+        if term > 0.5:
+            raise AssertionError("Arrays are not almost equal: %s (%s)" % (term, z))
+    
+
+def assert_equal(actual,desired,err_msg='',verbose=True):
+    from _numpypy import ndarray
+    if isinstance(desired, dict):
+        if not isinstance(actual, dict) :
+            raise AssertionError(repr(type(actual)))
+        assert_equal(len(actual),len(desired),err_msg,verbose)
+        for k,i in desired.items():
+            if k not in actual :
+                raise AssertionError(repr(k))
+            assert_equal(actual[k], desired[k], 'key=%r\n%s' % (k,err_msg), verbose)
+        return
+    if isinstance(desired, (list,tuple)) and isinstance(actual, (list,tuple)):
+        assert_equal(len(actual),len(desired),err_msg,verbose)
+        for k in range(len(desired)):
+            assert_equal(actual[k], desired[k], 'item=%r\n%s' % (k,err_msg), verbose)
+        return
+
+    if isinstance(actual, (ndarray, tuple, list)) \
+            or isinstance(desired, (ndarray, tuple, list)):
+        return assert_array_equal(actual, desired, err_msg)
+    
+    if desired != actual:
+        raise AssertionError(msg)
+
+def assert_almost_equal(actual,desired,decimal=7,err_msg='',verbose=True):
+    from _numpypy import round
+    if isinstance(actual, float):
+        z = [abs(actual - desired) * (10**decimal)]
+    else:
+        z = abs(actual.ravel() - desired.ravel()) * (10**decimal)
+    for term in z:
+        if term > 0.5:
+            raise AssertionError(err_msg)
+
+def assert_allclose(actual, desired, rtol=1e-7, atol=0,
+                    err_msg='', verbose=True):
+    from _numpypy import allclose, asanyarray
+    def compare(x, y):
+        return allclose(x, y, rtol=rtol, atol=atol)
+    actual, desired = asanyarray(actual), asanyarray(desired)
+    header = 'Not equal to tolerance rtol=%g, atol=%g' % (rtol, atol)
+    assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
+                         verbose=verbose, header=header)
+    
+
+#########
+
+class AppTestAny(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import any
+        y1 = [0, 0, 1, 0]
+        y2 = [0, 0, 0, 0]
+        y3 = [1, 0, 1, 0]
+        assert any(y1)
+        assert any(y3)
+        assert not any(y2)
+
+    def test_nd(self):
+        from _numpypy import any, sometrue
+        y1 = [[0, 0, 0], [0, 1, 0], [1, 1, 0]]
+        assert any(y1)
+        assert_array_equal(sometrue(y1, axis=0), [1, 1, 0])
+        assert_array_equal(sometrue(y1, axis=1), [0, 1, 1])
+
+
+class AppTestAverage(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import array, average, ones
+        y1 = array([1, 2, 3])
+        assert average(y1, axis=0) == 2.
+        y2 = array([1., 2., 3.])
+        assert average(y2, axis=0) == 2.
+        y3 = [0., 0., 0.]
+        assert average(y3, axis=0) == 0.
+
+        y4 = ones((4, 4))
+        y4[0, 1] = 0
+        y4[1, 0] = 2
+        assert_almost_equal(y4.mean(0), average(y4, 0))
+        assert_almost_equal(y4.mean(1), average(y4, 1))
+
+    def test_random(self):
+        from _numpypy import array, average, matrix
+        from _numpypy.random import rand
+        y5 = rand(5, 5)
+        assert_almost_equal(y5.mean(0), average(y5, 0))
+        assert_almost_equal(y5.mean(1), average(y5, 1))
+
+        y6 = matrix(rand(5, 5))
+        assert_array_equal(y6.mean(0), average(y6, 0))
+
+    def test_weights(self):
+        from _numpypy import arange, average, array
+        y = arange(10)
+        w = arange(10)
+        actual = average(y, weights=w)
+        desired = (arange(10) ** 2).sum()*1. / arange(10).sum()
+        assert_almost_equal(actual, desired)
+
+        y1 = array([[1, 2, 3], [4, 5, 6]])
+        w0 = [1, 2]
+        actual = average(y1, weights=w0, axis=0)
+        desired = array([3., 4., 5.])
+        assert_almost_equal(actual, desired)
+
+        w1 = [0, 0, 1]
+        actual = average(y1, weights=w1, axis=1)
+        desired = array([3., 6.])
+        assert_almost_equal(actual, desired)
+
+        # This should raise an error. Can we test for that ?
+        # assert_equal(average(y1, weights=w1), 9./2.)
+
+        # 2D Case
+        w2 = [[0, 0, 1], [0, 0, 2]]
+        desired = array([3., 6.])
+        assert_array_equal(average(y1, weights=w2, axis=1), desired)
+        assert_equal(average(y1, weights=w2), 5.)
+
+    def test_returned(self):
+        from _numpypy import array, average
+        y = array([[1, 2, 3], [4, 5, 6]])
+
+        # No weights
+        avg, scl = average(y, returned=True)
+        assert_equal(scl, 6.)
+
+        avg, scl = average(y, 0, returned=True)
+        assert_array_equal(scl, array([2., 2., 2.]))
+
+        avg, scl = average(y, 1, returned=True)
+        assert_array_equal(scl, array([3., 3.]))
+
+        # With weights
+        w0 = [1, 2]
+        avg, scl = average(y, weights=w0, axis=0, returned=True)
+        assert_array_equal(scl, array([3., 3., 3.]))
+
+        w1 = [1, 2, 3]
+        avg, scl = average(y, weights=w1, axis=1, returned=True)
+        assert_array_equal(scl, array([6., 6.]))
+
+        w2 = [[0, 0, 1], [1, 2, 3]]
+        avg, scl = average(y, weights=w2, axis=1, returned=True)
+        assert_array_equal(scl, array([1., 6.]))
+
+
+class AppTestSelect(BaseNumpyAppTest):
+    def _select(self, cond, values, default=0):
+        output = []
+        for m in range(len(cond)):
+            output += [V[m] for V, C in zip(values, cond) if C[m]] or [default]
+        return output
+
+    def test_basic(self):
+        from _numpypy import array, select
+        choices = [array([1, 2, 3]),
+                   array([4, 5, 6]),
+                   array([7, 8, 9])]
+        conditions = [array([0, 0, 0]),
+                      array([0, 1, 0]),
+                      array([0, 0, 1])]
+        assert_array_equal(select(conditions, choices, default=15),
+                           self._select(conditions, choices, default=15))
+
+        assert_equal(len(choices), 3)
+        assert_equal(len(conditions), 3)
+
+
+class AppTestInsert(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import insert
+        a = [1, 2, 3]
+        assert_equal(insert(a, 0, 1), [1, 1, 2, 3])
+        assert_equal(insert(a, 3, 1), [1, 2, 3, 1])
+        assert_equal(insert(a, [1, 1, 1], [1, 2, 3]), [1, 1, 2, 3, 2, 3])
+
+
+class AppTestAmax(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import amax
+        a = [3, 4, 5, 10, -3, -5, 6.0]
+        assert_equal(amax(a), 10.0)
+        b = [[3, 6.0, 9.0],
+             [4, 10.0, 5.0],
+             [8, 3.0, 2.0]]
+        assert_equal(amax(b, axis=0), [8.0, 10.0, 9.0])
+        assert_equal(amax(b, axis=1), [9.0, 10.0, 8.0])
+
+
+class AppTestAmin(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import amin
+        a = [3, 4, 5, 10, -3, -5, 6.0]
+        assert_equal(amin(a), -5.0)
+        b = [[3, 6.0, 9.0],
+             [4, 10.0, 5.0],
+             [8, 3.0, 2.0]]
+        assert_equal(amin(b, axis=0), [3.0, 3.0, 2.0])
+        assert_equal(amin(b, axis=1), [3.0, 4.0, 2.0])
+
+
+class AppTestPtp(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import ptp
+        a = [3, 4, 5, 10, -3, -5, 6.0]
+        assert_equal(ptp(a, axis=0), 15.0)
+        b = [[3, 6.0, 9.0],
+             [4, 10.0, 5.0],
+             [8, 3.0, 2.0]]
+        assert_equal(ptp(b, axis=0), [5.0, 7.0, 7.0])
+        assert_equal(ptp(b, axis= -1), [6.0, 6.0, 6.0])
+
+
+class AppTestCumsum(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import array, cumsum
+        from _numpypy import (int8, uint8, int16, uint16, int32, uint32,
+                              float32, float64, complex64, complex128)
+        ba = [1, 2, 10, 11, 6, 5, 4]
+        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
+        for ctype in [int8, uint8, int16, uint16, int32, uint32,
+                      float32, float64, complex64, complex128]:
+            a = array(ba, ctype)
+            a2 = array(ba2, ctype)
+            assert_array_equal(cumsum(a, axis=0), array([1, 3, 13, 24, 30, 35, 39], ctype))
+            assert_array_equal(cumsum(a2, axis=0), array([[1, 2, 3, 4], [6, 8, 10, 13],
+                                                         [16, 11, 14, 18]], ctype))
+            assert_array_equal(cumsum(a2, axis=1),
+                               array([[1, 3, 6, 10],
+                                      [5, 11, 18, 27],
+                                      [10, 13, 17, 22]], ctype))
+
+class AppTestProd(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import array, prod
+        from _numpypy import (int8, uint8, int16, uint16, int32, uint32,
+                              float32, float64, complex64, complex128)
+        ba = [1, 2, 10, 11, 6, 5, 4]
+        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
+        for ctype in [int16, uint16, int32, uint32,
+                      float32, float64, complex64, complex128]:
+            a = array(ba, ctype)
+            a2 = array(ba2, ctype)
+            if ctype in ['1', 'b']:
+                self.assertRaises(ArithmeticError, prod, a)
+                self.assertRaises(ArithmeticError, prod, a2, 1)
+                self.assertRaises(ArithmeticError, prod, a)
+            else:
+                assert_equal(prod(a, axis=0), 26400)
+                assert_array_equal(prod(a2, axis=0),
+                                   array([50, 36, 84, 180], ctype))
+                assert_array_equal(prod(a2, axis= -1), array([24, 1890, 600], ctype))
+
+
+class AppTestCumprod(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import array, cumprod
+        from _numpypy import (int8, uint8, int16, uint16, int32, uint32,
+                              float32, float64, complex64, complex128)
+        ba = [1, 2, 10, 11, 6, 5, 4]
+        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
+        for ctype in [int16, uint16, int32, uint32,
+                      float32, float64, complex64, complex128]:
+            a = array(ba, ctype)
+            a2 = array(ba2, ctype)
+            if ctype in ['1', 'b']:
+                self.assertRaises(ArithmeticError, cumprod, a)
+                self.assertRaises(ArithmeticError, cumprod, a2, 1)
+                self.assertRaises(ArithmeticError, cumprod, a)
+            else:
+                assert_array_equal(cumprod(a, axis= -1),
+                                   array([1, 2, 20, 220,
+                                          1320, 6600, 26400], ctype))
+                assert_array_equal(cumprod(a2, axis=0),
+                                   array([[ 1, 2, 3, 4],
+                                          [ 5, 12, 21, 36],
+                                          [50, 36, 84, 180]], ctype))
+                assert_array_equal(cumprod(a2, axis= -1),
+                                   array([[ 1, 2, 6, 24],
+                                          [ 5, 30, 210, 1890],
+                                          [10, 30, 120, 600]], ctype))
+
+class AppTestDiff(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import array, diff
+        x = [1, 4, 6, 7, 12]
+        out = array([3, 2, 1, 5])
+        out2 = array([-1, -1, 4])
+        out3 = array([0, 5])
+        assert_array_equal(diff(x), out)
+        assert_array_equal(diff(x, n=2), out2)
+        assert_array_equal(diff(x, n=3), out3)
+
+    def test_nd(self):
+        from _numpypy import array, diff
+        from _numpypy.random import rand
+        x = 20 * rand(10, 20, 30)
+        out1 = x[:, :, 1:] - x[:, :, :-1]
+        out2 = out1[:, :, 1:] - out1[:, :, :-1]
+        out3 = x[1:, :, :] - x[:-1, :, :]
+        out4 = out3[1:, :, :] - out3[:-1, :, :]
+        assert_array_equal(diff(x), out1)
+        assert_array_equal(diff(x, n=2), out2)
+        assert_array_equal(diff(x, axis=0), out3)
+        assert_array_equal(diff(x, n=2, axis=0), out4)
+
+
+class AppTestGradient(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import array, gradient
+        x = array([[1, 1], [3, 4]])
+        dx = [array([[2., 3.], [2., 3.]]),
+              array([[0., 0.], [1., 1.]])]
+        assert_array_equal(gradient(x), dx)
+
+    def test_badargs(self):
+        from _numpypy import array, gradient
+        # for 2D array, gradient can take 0, 1, or 2 extra args
+        x = array([[1, 1], [3, 4]])
+        assert_raises(SyntaxError, gradient, x, array([1., 1.]),
+                      array([1., 1.]), array([1., 1.]))
+
+    def test_masked(self):
+        from _numpypy import array, gradient
+        # Make sure that gradient supports subclasses like masked arrays
+        x = array([[1, 1], [3, 4]])
+        assert_equal(type(gradient(x)[0]), type(x))
+
+class AppTestAngle(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import angle, pi, arctan, sqrt, array
+        x = [1 + 3j, sqrt(2) / 2.0 + 1j * sqrt(2) / 2, 1, 1j, -1, -1j, 1 - 3j, -1 + 3j]
+        y = angle(x)
+        yo = array([arctan(3.0 / 1.0), arctan(1.0), 0, pi / 2, pi, -pi / 2.0,
+                    - arctan(3.0 / 1.0), pi - arctan(3.0 / 1.0)])
+        z = angle(x, deg=1)
+        zo = array(yo) * 180 / pi
+        assert_array_almost_equal(y, yo, 11)
+        assert_array_almost_equal(z, zo, 11)
+
+
+class AppTestTrimZeros(BaseNumpyAppTest):
+    """ only testing for integer splits.
+    """
+    def test_basic(self):
+        from _numpypy import array, trim_zeros
+        a = array([0, 0, 1, 2, 3, 4, 0])
+        res = trim_zeros(a)
+        assert_array_equal(res, array([1, 2, 3, 4]))
+
+    def test_leading_skip(self):
+        from _numpypy import array, trim_zeros
+        a = array([0, 0, 1, 0, 2, 3, 4, 0])
+        res = trim_zeros(a)
+        assert_array_equal(res, array([1, 0, 2, 3, 4]))
+
+    def test_trailing_skip(self):
+        from _numpypy import array, trim_zeros
+        a = array([0, 0, 1, 0, 2, 3, 0, 4, 0])
+        res = trim_zeros(a)
+        assert_array_equal(res, array([1, 0, 2, 3, 0, 4]))
+
+class AppTestExtins(BaseNumpyAppTest):
+    def test_basic(self):
+        from _numpypy import array, extract
+        a = array([1, 3, 2, 1, 2, 3, 3])
+        b = extract(a > 1, a)
+        assert_array_equal(b, [3, 2, 2, 3, 3])
+
+    def test_place(self):
+        from _numpypy import array, place
+        a = array([1, 4, 3, 2, 5, 8, 7])
+        place(a, [0, 1, 0, 1, 0, 1, 0], [2, 4, 6])
+        assert_array_equal(a, [1, 2, 3, 4, 5, 6, 7])
+
+    def test_both(self):
+        from _numpypy import extract, place
+        from _numpypy.random import rand
+        a = rand(10)
+        mask = a > 0.5
+        ac = a.copy()
+        c = extract(mask, a)
+        place(a, mask, 0)
+        place(a, mask, c)
+        assert_array_equal(a, ac)
+
+class AppTestVectorize(BaseNumpyAppTest):
+    def test_simple(self):
+        from _numpypy import vectorize
+        def addsubtract(a, b):
+            if a > b:
+                return a - b
+            else:
+                return a + b
+        f = vectorize(addsubtract)
+        r = f([0, 3, 6, 9], [1, 3, 5, 7])
+        assert_array_equal(r, [1, 6, 1, 2])
+
+    def test_scalar(self):
+        from _numpypy import vectorize
+        def addsubtract(a, b):
+            if a > b:
+                return a - b
+            else:
+                return a + b
+        f = vectorize(addsubtract)
+        r = f([0, 3, 6, 9], 5)
+        assert_array_equal(r, [5, 8, 1, 4])
+
+    def test_large(self):
+        from _numpypy import linspace, vectorize
+        x = linspace(-3, 2, 10000)
+        f = vectorize(lambda x: x)
+        y = f(x)
+        assert_array_equal(y, x)
+
+    def test_ufunc(self):
+        from _numpypy import array, vectorize, cos, pi
+        import math
+        f = vectorize(math.cos)
+        args = array([0, 0.5*pi, pi, 1.5*pi, 2*pi])
+        r1 = f(args)
+        r2 = cos(args)
+        assert_array_equal(r1, r2)
+
+    def test_keywords(self):
+        from _numpypy import array, vectorize
+        import math
+        def foo(a, b=1):
+            return a + b
+        f = vectorize(foo)
+        args = array([1,2,3])
+        r1 = f(args)
+        r2 = array([2,3,4])
+        assert_array_equal(r1, r2)
+        r1 = f(args, 2)
+        r2 = array([3,4,5])
+        assert_array_equal(r1, r2)
+
+    def test_keywords_no_func_code(self):
+        from _numpypy import vectorize
+        # This needs to test a function that has keywords but
+        # no func_code attribute, since otherwise vectorize will
+        # inspect the func_code.
+        import random
+        try:
+            f = vectorize(random.randrange)
+        except:
+            raise AssertionError()
+
+class AppTestDigitize(BaseNumpyAppTest):
+    def test_forward(self):
+        from _numpypy import arange, digitize
+        x = arange(-6, 5)
+        bins = arange(-5, 5)
+        assert_array_equal(digitize(x, bins), arange(11))
+
+    def test_reverse(self):
+        from _numpypy import arange, digitize
+        x = arange(5, -6, -1)
+        bins = arange(5, -5, -1)
+        assert_array_equal(digitize(x, bins), arange(11))
+
+    def test_random(self):
+        from _numpypy import arange, linspace, digitize
+        from _numpypy.random import rand
+        x = rand(10)
+        bin = linspace(x.min(), x.max(), 10)
+        assert all(digitize(x, bin) != 0)
+
+class AppTestUnwrap(BaseNumpyAppTest):
+    def test_simple(self):
+        from _numpypy import unwrap, pi, diff
+        from _numpypy.random import rand
+        #check that unwrap removes jumps greater than 2*pi
+        assert_array_equal(unwrap([1, 1 + 2 * pi]), [1, 1])
+        #check that unwrap maintans continuity
+        assert all(diff(unwrap(rand(10) * 100)) < pi)
+
+
+class AppTestFilterwindows(BaseNumpyAppTest):
+    def test_hanning(self):
+        from _numpypy import hanning, flipud, sum
+        #check symmetry
+        w = hanning(10)
+        assert_array_almost_equal(w, flipud(w), 7)
+        #check known value
+        assert_almost_equal(sum(w, axis=0), 4.500, 4)
+
+    def test_hamming(self):
+        from _numpypy import hamming, flipud, sum
+        #check symmetry
+        w = hamming(10)
+        assert_array_almost_equal(w, flipud(w), 7)
+        #check known value
+        assert_almost_equal(sum(w, axis=0), 4.9400, 4)
+
+    def test_bartlett(self):
+        from _numpypy import bartlett, flipud, sum
+        #check symmetry
+        w = bartlett(10)
+        assert_array_almost_equal(w, flipud(w), 7)
+        #check known value
+        assert_almost_equal(sum(w, axis=0), 4.4444, 4)
+
+    def test_blackman(self):
+        from _numpypy import blackman, flipud, sum
+        #check symmetry
+        w = blackman(10)
+        assert_array_almost_equal(w, flipud(w), 7)
+        #check known value
+        assert_almost_equal(sum(w, axis=0), 3.7800, 4)
+
+class AppTestTrapz(BaseNumpyAppTest):
+    def test_simple(self):
+        from _numpypy import trapz, arange, sqrt, pi, sum, exp
+        r = trapz(exp(-1.0 / 2 * (arange(-10, 10, .1)) ** 2) / sqrt(2 * pi), dx=0.1)
+        #check integral of normal equals 1
+        assert_almost_equal(sum(r, axis=0), 1, 7)
+
+    def test_ndim(self):
+        from _numpypy import linspace, ones_like, trapz
+        x = linspace(0, 1, 3)
+        y = linspace(0, 2, 8)
+        z = linspace(0, 3, 13)
+
+        wx = ones_like(x) * (x[1] - x[0])
+        wx[0] /= 2
+        wx[-1] /= 2
+        wy = ones_like(y) * (y[1] - y[0])
+        wy[0] /= 2
+        wy[-1] /= 2
+        wz = ones_like(z) * (z[1] - z[0])
+        wz[0] /= 2
+        wz[-1] /= 2
+
+        q = x[:, None, None] + y[None, :, None] + z[None, None, :]
+
+        qx = (q * wx[:, None, None]).sum(axis=0)
+        qy = (q * wy[None, :, None]).sum(axis=1)
+        qz = (q * wz[None, None, :]).sum(axis=2)
+
+        # n-d `x`
+        r = trapz(q, x=x[:, None, None], axis=0)
+        assert_almost_equal(r, qx)
+        r = trapz(q, x=y[None, :, None], axis=1)
+        assert_almost_equal(r, qy)
+        r = trapz(q, x=z[None, None, :], axis=2)
+        assert_almost_equal(r, qz)
+
+        # 1-d `x`
+        r = trapz(q, x=x, axis=0)
+        assert_almost_equal(r, qx)
+        r = trapz(q, x=y, axis=1)
+        assert_almost_equal(r, qy)
+        r = trapz(q, x=z, axis=2)
+        assert_almost_equal(r, qz)
+
+    def test_masked(self):
+        from _numpypy import arange, trapz
+        from _numpypy import ma
+        #Testing that masked arrays behave as if the function is 0 where masked
+        x = arange(5)
+        y = x * x
+        mask = x == 2
+        ym = ma.array(y, mask=mask)
+        r = 13.0 # sum(0.5 * (0 + 1) * 1.0 + 0.5 * (9 + 16))
+        assert_almost_equal(trapz(ym, x), r)
+
+        xm = ma.array(x, mask=mask)
+        assert_almost_equal(trapz(ym, xm), r)
+
+        xm = ma.array(x, mask=mask)
+        assert_almost_equal(trapz(y, xm), r)
+
+    def test_matrix(self):
+        from _numpypy import linspace, trapz, matrix
+        #Test to make sure matrices give the same answer as ndarrays
+        x = linspace(0, 5)
+        y = x * x
+        r = trapz(y, x)
+        mx = matrix(x)
+        my = matrix(y)
+        mr = trapz(my, mx)
+        assert_almost_equal(mr, r)
+
+
+class AppTestSinc(BaseNumpyAppTest):
+    def test_simple(self):
+        from _numpypy import sinc, linspace, flipud
+        assert sinc(0) == 1
+        w = sinc(linspace(-1, 1, 100))
+        #check symmetry
+        assert_array_almost_equal(w, flipud(w), 7)
+
+    def test_array_like(self):
+        from _numpypy import sinc, array
+        x = [0, 0.5]
+        y1 = sinc(array(x))
+        y2 = sinc(list(x))
+        y3 = sinc(tuple(x))
+        assert_array_equal(y1, y2)
+        assert_array_equal(y1, y3)
+
+class AppTestHistogram(BaseNumpyAppTest):
+    def test_simple(self):
+        from _numpypy import histogram, sum, linspace
+        from _numpypy.random import rand
+        n = 100
+        v = rand(n)
+        (a, b) = histogram(v)
+        #check if the sum of the bins equals the number of samples
+        assert_equal(sum(a, axis=0), n)
+        #check that the bin counts are evenly spaced when the data is from a
+        # linear function
+        (a, b) = histogram(linspace(0, 10, 100))
+        assert_array_equal(a, 10)
+
+    def test_one_bin(self):
+        from _numpypy import histogram, array
+        # numpy ticket 632
+        hist, edges = histogram([1, 2, 3, 4], [1, 2])
+        assert_array_equal(hist, [2, ])
+        assert_array_equal(edges, [1, 2])
+        assert_raises(ValueError, histogram, [1, 2], bins=0)
+        h, e = histogram([1,2], bins=1)
+        assert_equal(h, array([2]))
+        assert_allclose(e, array([1., 2.]))
+
+    def test_normed(self):
+        from _numpypy import histogram, sum, diff, arange
+        from _numpypy.random import rand
+        # Check that the integral of the density equals 1.
+        n = 100
+        v = rand(n)
+        a, b = histogram(v, normed=True)
+        area = sum(a * diff(b))
+        assert_almost_equal(area, 1)
+
+        # Check with non-constant bin widths (buggy but backwards compatible)
+        v = arange(10)
+        bins = [0, 1, 5, 9, 10]
+        a, b = histogram(v, bins, normed=True)
+        area = sum(a * diff(b))
+        assert_almost_equal(area, 1)
+
+    def test_density(self):
+        from _numpypy import histogram, diff, arange, inf
+        from _numpypy.random import rand
+        # Check that the integral of the density equals 1.
+        n = 100
+        v = rand(n)
+        a, b = histogram(v, density=True)
+        area = sum(a * diff(b))
+        assert_almost_equal(area, 1)
+
+        # Check with non-constant bin widths
+        v = arange(10)
+        bins = [0,1,3,6,10]
+        a, b = histogram(v, bins, density=True)
+        assert_array_equal(a, .1)
+        assert_equal(sum(a*diff(b)), 1)
+
+        # Variale bin widths are especially useful to deal with infinities.
+        v = arange(10)
+        bins = [0,1,3,6,inf]
+        a, b = histogram(v, bins, density=True)
+        assert_array_equal(a, [.1,.1,.1,0.])
+
+        # Taken from a bug report from N. Becker on the numpy-discussion
+        # mailing list Aug. 6, 2010.
+        counts, dmy = histogram([1,2,3,4], [0.5,1.5,inf], density=True)
+        assert_equal(counts, [.25, 0])
+
+    def test_outliers(self):
+        from _numpypy import arange, histogram, diff
+        # Check that outliers are not tallied
+        a = arange(10) + .5
+
+        # Lower outliers
+        h, b = histogram(a, range=[0, 9])
+        assert_equal(h.sum(), 9)
+
+        # Upper outliers
+        h, b = histogram(a, range=[1, 10])
+        assert_equal(h.sum(), 9)
+
+        # Normalization
+        h, b = histogram(a, range=[1, 9], normed=True)
+        assert_equal((h * diff(b)).sum(), 1)
+
+        # Weights
+        w = arange(10) + .5
+        h, b = histogram(a, range=[1, 9], weights=w, normed=True)
+        assert_equal((h * diff(b)).sum(), 1)
+
+        h, b = histogram(a, bins=8, range=[1, 9], weights=w)
+        assert_equal(h, w[1:-1])
+
+    def test_type(self):
+        from _numpypy import arange, histogram, issubdtype, ones
+        # Check the type of the returned histogram
+        a = arange(10) + .5
+        h, b = histogram(a)
+        assert issubdtype(h.dtype, int)
+
+        h, b = histogram(a, normed=True)
+        assert issubdtype(h.dtype, float)
+
+        h, b = histogram(a, weights=ones(10, int))
+        assert issubdtype(h.dtype, int)
+
+        h, b = histogram(a, weights=ones(10, float))
+        assert issubdtype(h.dtype, float)
+
+    def test_weights(self):
+        from _numpypy import ones, histogram, linspace, concatenate, zeros, arange, array
+        from _numpypy.random import rand
+        v = rand(100)
+        w = ones(100) * 5
+        a, b = histogram(v)
+        na, nb = histogram(v, normed=True)
+        wa, wb = histogram(v, weights=w)
+        nwa, nwb = histogram(v, weights=w, normed=True)
+        assert_array_almost_equal(a * 5, wa)
+        assert_array_almost_equal(na, nwa)
+
+        # Check weights are properly applied.
+        v = linspace(0, 10, 10)
+        w = concatenate((zeros(5), ones(5)))
+        wa, wb = histogram(v, bins=arange(11), weights=w)
+        assert_array_almost_equal(wa, w)
+
+        # Check with integer weights
+        wa, wb = histogram([1, 2, 2, 4], bins=4, weights=[4, 3, 2, 1])
+        assert_array_equal(wa, [4, 5, 0, 1])
+        wa, wb = histogram([1, 2, 2, 4], bins=4, weights=[4, 3, 2, 1], normed=True)
+        assert_array_almost_equal(wa, array([4, 5, 0, 1]) / 10. / 3. * 4)
+
+        # Check weights with non-uniform bin widths
+        a,b = histogram(arange(9), [0,1,3,6,10], \
+                        weights=[2,1,1,1,1,1,1,1,1], density=True)
+        assert_almost_equal(a, array([.2, .1, .1, .075]))
+
+    def test_empty(self):
+        from _numpypy import histogram, array
+        a, b = histogram([], bins=([0,1]))
+        assert_array_equal(a, array([0]))
+        assert_array_equal(b, array([0, 1]))
+
+class AppTestHistogramdd(BaseNumpyAppTest):
+    def test_simple(self):
+        from _numpypy import array, histogram, asarray, histogramdd, squeeze, zeros, arange, all, split
+        x = array([[-.5, .5, 1.5], [-.5, 1.5, 2.5], [-.5, 2.5, .5], \
+        [.5, .5, 1.5], [.5, 1.5, 2.5], [.5, 2.5, 2.5]])
+        H, edges = histogramdd(x, (2, 3, 3), range=[[-1, 1], [0, 3], [0, 3]])
+        answer = asarray([[[0, 1, 0], [0, 0, 1], [1, 0, 0]], [[0, 1, 0], [0, 0, 1],
+            [0, 0, 1]]])
+        assert_array_equal(H, answer)
+        # Check normalization
+        ed = [[-2, 0, 2], [0, 1, 2, 3], [0, 1, 2, 3]]
+        H, edges = histogramdd(x, bins=ed, normed=True)
+        assert all(H == answer / 12.)
+        # Check that H has the correct shape.
+        H, edges = histogramdd(x, (2, 3, 4), range=[[-1, 1], [0, 3], [0, 4]],
+            normed=True)
+        answer = asarray([[[0, 1, 0, 0], [0, 0, 1, 0], [1, 0, 0, 0]], [[0, 1, 0, 0],
+            [0, 0, 1, 0], [0, 0, 1, 0]]])
+        assert_array_almost_equal(H, answer / 6., 4)
+        # Check that a sequence of arrays is accepted and H has the correct
+        # shape.
+        z = [squeeze(y) for y in split(x, 3, axis=1)]
+        H, edges = histogramdd(z, bins=(4, 3, 2), range=[[-2, 2], [0, 3], [0, 2]])
+        answer = asarray([[[0, 0], [0, 0], [0, 0]],
+                          [[0, 1], [0, 0], [1, 0]],
+                          [[0, 1], [0, 0], [0, 0]],
+                          [[0, 0], [0, 0], [0, 0]]])
+        assert_array_equal(H, answer)
+
+        Z = zeros((5, 5, 5))
+        Z[range(5), range(5), range(5)] = 1.
+        H, edges = histogramdd([arange(5), arange(5), arange(5)], 5)
+        assert_array_equal(H, Z)
+
+    def test_shape_3d(self):
+        from _numpypy import histogramdd
+        from _numpypy.random import rand
+        # All possible permutations for bins of different lengths in 3D.
+        bins = ((5, 4, 6), (6, 4, 5), (5, 6, 4), (4, 6, 5), (6, 5, 4),
+            (4, 5, 6))
+        r = rand(10, 3)
+        for b in bins:
+            H, edges = histogramdd(r, b)
+            assert H.shape == b
+
+    def test_shape_4d(self):
+        from _numpypy import histogramdd
+        from _numpypy.random import rand
+        # All possible permutations for bins of different lengths in 4D.
+        bins = ((7, 4, 5, 6), (4, 5, 7, 6), (5, 6, 4, 7), (7, 6, 5, 4),
+            (5, 7, 6, 4), (4, 6, 7, 5), (6, 5, 7, 4), (7, 5, 4, 6),
+            (7, 4, 6, 5), (6, 4, 7, 5), (6, 7, 5, 4), (4, 6, 5, 7),
+            (4, 7, 5, 6), (5, 4, 6, 7), (5, 7, 4, 6), (6, 7, 4, 5),
+            (6, 5, 4, 7), (4, 7, 6, 5), (4, 5, 6, 7), (7, 6, 4, 5),
+            (5, 4, 7, 6), (5, 6, 7, 4), (6, 4, 5, 7), (7, 5, 6, 4))
+
+        r = rand(10, 4)
+        for b in bins:
+            H, edges = histogramdd(r, b)
+            assert H.shape == b
+
+    def test_weights(self):
+        from _numpypy import histogramdd, ones
+        from _numpypy.random import rand
+        v = rand(100, 2)
+        hist, edges = histogramdd(v)
+        n_hist, edges = histogramdd(v, normed=True)
+        w_hist, edges = histogramdd(v, weights=ones(100))
+        assert_array_equal(w_hist, hist)
+        w_hist, edges = histogramdd(v, weights=ones(100) * 2, normed=True)
+        assert_array_equal(w_hist, n_hist)
+        w_hist, edges = histogramdd(v, weights=ones(100, int) * 2)
+        assert_array_equal(w_hist, 2 * hist)
+
+    def test_identical_samples(self):
+        from _numpypy import zeros, histogramdd, array
+        x = zeros((10, 2), int)
+        hist, edges = histogramdd(x, bins=2)
+        assert_array_equal(edges[0], array([-0.5, 0. , 0.5]))
+
+    def test_empty(self):
+        from _numpypy import histogramdd, array, zeros
+        a, b = histogramdd([[], []], bins=([0,1], [0,1]))
+        assert_array_equal(a, array([[ 0.]]))
+        a, b = histogramdd([[], [], []], bins=2)
+        assert_array_equal(a, zeros((2, 2, 2)))
+
+
+    def test_bins_errors(self):
+        """There are two ways to specify bins. Check for the right errors when
+        mixing those."""
+        from _numpypy import arange, histogramdd
+        x = arange(8).reshape(2, 4)
+        assert_raises(ValueError, histogramdd, x, bins=[-1, 2, 4, 5])
+        assert_raises(ValueError, histogramdd, x, bins=[1, 0.99, 1, 1])
+        assert_raises(ValueError, histogramdd, x, bins=[1, 1, 1, [1, 2, 2, 3]])
+        assert_raises(ValueError, histogramdd, x, bins=[1, 1, 1, [1, 2, 3, -3]])
+        assert histogramdd(x, bins=[1, 1, 1, [1, 2, 3, 4]])
+
+    def test_inf_edges(self):
+        """Test using +/-inf bin edges works. See #1788."""
+        from _numpypy import arange, array, histogramdd, inf
+        x = arange(6).reshape(3, 2)
+        expected = array([[1, 0], [0, 1], [0, 1]])
+        h, e = histogramdd(x, bins=[3, [-inf, 2, 10]])
+        assert_allclose(h, expected)
+        h, e = histogramdd(x, bins=[3, array([-1, 2, inf])])
+        assert_allclose(h, expected)
+        h, e = histogramdd(x, bins=[3, [-inf, 3, inf]])
+        assert_allclose(h, expected)
+
+class AppTestUnique(BaseNumpyAppTest):
+    def test_simple(self):
+        from _numpypy import array, all, unique
+        x = array([4, 3, 2, 1, 1, 2, 3, 4, 0])
+        assert all(unique(x) == [0, 1, 2, 3, 4])
+        assert unique(array([1, 1, 1, 1, 1])) == array([1])
+        x = ['widget', 'ham', 'foo', 'bar', 'foo', 'ham']
+        assert all(unique(x) == ['bar', 'foo', 'ham', 'widget'])
+        x = array([5 + 6j, 1 + 1j, 1 + 10j, 10, 5 + 6j])
+        assert all(unique(x) == [1 + 1j, 1 + 10j, 5 + 6j, 10])
+
+class AppTestCheckFinite(BaseNumpyAppTest):
+    def test_simple(self):
+        from _numpypy import lib, inf, nan
+        a = [1, 2, 3]
+        b = [1, 2, inf]
+        c = [1, 2, nan]
+        lib.asarray_chkfinite(a)
+        assert_raises(ValueError, lib.asarray_chkfinite, b)
+        assert_raises(ValueError, lib.asarray_chkfinite, c)
+
+
+class AppTestNaNFuncts(BaseNumpyAppTest):
+    def setup_class(cls):
+        super(AppTestNaNFuncts, cls).setup_class()
+        cls.w_A = cls.space.appexec([], """
+            from _numpypy import array
+            return array([[[ nan, 0.01319214, 0.01620964],
+                           [ 0.11704017, nan, 0.75157887],
+                           [ 0.28333658, 0.1630199 , nan       ]],
+                          [[ 0.59541557, nan, 0.37910852],
+                           [ nan, 0.87964135, nan       ],
+                           [ 0.70543747, nan, 0.34306596]],
+                          [[ 0.72687499, 0.91084584, nan       ],
+                           [ 0.84386844, 0.38944762, 0.23913896],
+                           [ nan, 0.37068164, 0.33850425]]])
+                    """)
+        
+
+    def test_nansum(self):
+        from _numpypy import nansum, array
+        assert_almost_equal(nansum(self.A), 8.0664079100000006)
+        assert_almost_equal(nansum(self.A, 0),
+                            array([[ 1.32229056, 0.92403798, 0.39531816],
+                                   [ 0.96090861, 1.26908897, 0.99071783],
+                                   [ 0.98877405, 0.53370154, 0.68157021]]))
+        assert_almost_equal(nansum(self.A, 1),
+                            array([[ 0.40037675, 0.17621204, 0.76778851],
+                                   [ 1.30085304, 0.87964135, 0.72217448],
+                                   [ 1.57074343, 1.6709751 , 0.57764321]]))
+        assert_almost_equal(nansum(self.A, 2),
+                            array([[ 0.02940178, 0.86861904, 0.44635648],
+                                   [ 0.97452409, 0.87964135, 1.04850343],
+                                   [ 1.63772083, 1.47245502, 0.70918589]]))
+
+    def test_nanmin(self):
+        from _numpypy import nanmin, array, nan, isnan
+        assert_almost_equal(nanmin(self.A), 0.01319214)
+        assert_almost_equal(nanmin(self.A, 0),
+                            array([[ 0.59541557, 0.01319214, 0.01620964],
+                                   [ 0.11704017, 0.38944762, 0.23913896],
+                                   [ 0.28333658, 0.1630199 , 0.33850425]]))
+        assert_almost_equal(nanmin(self.A, 1),
+                            array([[ 0.11704017, 0.01319214, 0.01620964],
+                                   [ 0.59541557, 0.87964135, 0.34306596],
+                                   [ 0.72687499, 0.37068164, 0.23913896]]))
+        assert_almost_equal(nanmin(self.A, 2),
+                            array([[ 0.01319214, 0.11704017, 0.1630199 ],
+                                   [ 0.37910852, 0.87964135, 0.34306596],
+                                   [ 0.72687499, 0.23913896, 0.33850425]]))
+        assert isnan(nanmin([nan, nan]))
+
+    def test_nanargmin(self):
+        from _numpypy import nanargmin, array
+        assert_almost_equal(nanargmin(self.A), 1)
+        assert_almost_equal(nanargmin(self.A, 0),
+                            array([[1, 0, 0],
+                                   [0, 2, 2],
+                                   [0, 0, 2]]))
+        assert_almost_equal(nanargmin(self.A, 1),
+                            array([[1, 0, 0],
+                                   [0, 1, 2],
+                                   [0, 2, 1]]))
+        assert_almost_equal(nanargmin(self.A, 2),
+                            array([[1, 0, 1],
+                                   [2, 1, 2],
+                                   [0, 2, 2]]))
+
+    def test_nanmax(self):
+        from _numpypy import nanmax, array, nan, isnan
+        assert_almost_equal(nanmax(self.A), 0.91084584000000002)
+        assert_almost_equal(nanmax(self.A, 0),
+                            array([[ 0.72687499, 0.91084584, 0.37910852],
+                                   [ 0.84386844, 0.87964135, 0.75157887],
+                                   [ 0.70543747, 0.37068164, 0.34306596]]))
+        assert_almost_equal(nanmax(self.A, 1),
+                            array([[ 0.28333658, 0.1630199 , 0.75157887],
+                                   [ 0.70543747, 0.87964135, 0.37910852],
+                                   [ 0.84386844, 0.91084584, 0.33850425]]))
+        assert_almost_equal(nanmax(self.A, 2),
+                            array([[ 0.01620964, 0.75157887, 0.28333658],
+                                   [ 0.59541557, 0.87964135, 0.70543747],
+                                   [ 0.91084584, 0.84386844, 0.37068164]]))
+        assert isnan(nanmax([nan, nan]))
+
+    def test_nanmin_allnan_on_axis(self):
+        from _numpypy import nanmin, isnan, nan
+        assert_array_equal(isnan(nanmin([[nan] * 2] * 3, axis=1)),
+                     [True, True, True])
+
+    def test_nanmin_masked(self):
+        from _numpypy import nan, nanmin, isinf, zeros
+        from _numpypy import ma
+        a = ma.fix_invalid([[2, 1, 3, nan], [5, 2, 3, nan]])
+        ctrl_mask = a._mask.copy()
+        test = nanmin(a, axis=1)
+        assert_equal(test, [1, 2])
+        assert_equal(a._mask, ctrl_mask)
+        assert_equal(isinf(a), zeros((2, 4), dtype=bool))
+
+'''
+class AppTestNanFunctsIntTypes(BaseNumpyAppTest):
+
+    int_types = (int8, int16, int32, int64, uint8, uint16, uint32, uint64)
+
+    def setUp(self, *args, **kwargs):
+        self.A = array([127, 39,  93,  87, 46])
+
+    def integer_arrays(self):
+        for dtype in self.int_types:
+            yield self.A.astype(dtype)
+
+    def test_nanmin(self):
+        min_value = min(self.A)
+        for A in self.integer_arrays():
+            assert_equal(nanmin(A), min_value)
+
+    def test_nanmax(self):
+        max_value = max(self.A)
+        for A in self.integer_arrays():
+            assert_equal(nanmax(A), max_value)
+
+    def test_nanargmin(self):
+        min_arg = argmin(self.A)
+        for A in self.integer_arrays():
+            assert_equal(nanargmin(A), min_arg)
+
+    def test_nanargmax(self):
+        max_arg = argmax(self.A)
+        for A in self.integer_arrays():
+            assert_equal(nanargmax(A), max_arg)
+
+
+class AppTestCorrCoef(BaseNumpyAppTest):
+    A = array([[ 0.15391142, 0.18045767, 0.14197213],
+               [ 0.70461506, 0.96474128, 0.27906989],
+               [ 0.9297531 , 0.32296769, 0.19267156]])
+    B = array([[ 0.10377691, 0.5417086 , 0.49807457],
+               [ 0.82872117, 0.77801674, 0.39226705],
+               [ 0.9314666 , 0.66800209, 0.03538394]])
+    res1 = array([[ 1.        , 0.9379533 , -0.04931983],
+               [ 0.9379533 , 1.        , 0.30007991],
+               [-0.04931983, 0.30007991, 1.        ]])
+    res2 = array([[ 1.        , 0.9379533 , -0.04931983,
+                 0.30151751, 0.66318558, 0.51532523],
+               [ 0.9379533 , 1.        , 0.30007991,
+                 - 0.04781421, 0.88157256, 0.78052386],
+               [-0.04931983, 0.30007991, 1.        ,
+                 - 0.96717111, 0.71483595, 0.83053601],
+               [ 0.30151751, -0.04781421, -0.96717111,
+                 1.        , -0.51366032, -0.66173113],
+               [ 0.66318558, 0.88157256, 0.71483595,
+                 - 0.51366032, 1.        , 0.98317823],
+               [ 0.51532523, 0.78052386, 0.83053601,
+                 - 0.66173113, 0.98317823, 1.        ]])
+
+    def test_simple(self):
+        assert_almost_equal(corrcoef(self.A), self.res1)
+        assert_almost_equal(corrcoef(self.A, self.B), self.res2)
+
+    def test_ddof(self):
+        assert_almost_equal(corrcoef(self.A, ddof=-1), self.res1)
+        assert_almost_equal(corrcoef(self.A, self.B, ddof=-1), self.res2)
+
+    def test_empty(self):
+        assert_equal(corrcoef(np.array([])).size, 0)
+        assert_equal(corrcoef(np.array([]).reshape(0, 2)).shape, (0, 2))
+
+
+class AppTestCov(BaseNumpyAppTest):
+    def test_basic(self):
+        x = np.array([[0, 2], [1, 1], [2, 0]]).T
+        assert_allclose(np.cov(x), np.array([[ 1.,-1.], [-1.,1.]]))
+
+    def test_empty(self):
+        assert_equal(cov(np.array([])).size, 0)
+        assert_equal(cov(np.array([]).reshape(0, 2)).shape, (0, 2))
+
+
+class AppTest_i0(BaseNumpyAppTest):
+    def test_simple(self):
+        assert_almost_equal(i0(0.5), array(1.0634833707413234))
+        A = array([ 0.49842636, 0.6969809 , 0.22011976, 0.0155549])
+        assert_almost_equal(i0(A),
+                            array([ 1.06307822, 1.12518299, 1.01214991, 1.00006049]))
+        B = array([[ 0.827002  , 0.99959078],
+                   [ 0.89694769, 0.39298162],
+                   [ 0.37954418, 0.05206293],
+                   [ 0.36465447, 0.72446427],
+                   [ 0.48164949, 0.50324519]])
+        assert_almost_equal(i0(B),
+                            array([[ 1.17843223, 1.26583466],
+                                   [ 1.21147086, 1.0389829 ],
+                                   [ 1.03633899, 1.00067775],
+                                   [ 1.03352052, 1.13557954],
+                                   [ 1.0588429 , 1.06432317]]))
+
+
+class AppTestKaiser(BaseNumpyAppTest):
+    def test_simple(self):
+        assert_almost_equal(kaiser(0, 1.0), array([]))
+        assert isfinite(kaiser(1, 1.0))
+        assert_almost_equal(kaiser(2, 1.0), array([ 0.78984831, 0.78984831]))
+        assert_almost_equal(kaiser(5, 1.0),
+                            array([ 0.78984831, 0.94503323, 1.        ,
+                                    0.94503323, 0.78984831]))
+        assert_almost_equal(kaiser(5, 1.56789),
+                            array([ 0.58285404, 0.88409679, 1.        ,
+                                    0.88409679, 0.58285404]))
+
+    def test_int_beta(self):
+        kaiser(3, 4)
+
+
+class AppTestMsort(BaseNumpyAppTest):
+    def test_simple(self):
+        A = array([[ 0.44567325, 0.79115165, 0.5490053 ],
+                   [ 0.36844147, 0.37325583, 0.96098397],
+                   [ 0.64864341, 0.52929049, 0.39172155]])
+        assert_almost_equal(msort(A),
+                            array([[ 0.36844147, 0.37325583, 0.39172155],
+                                   [ 0.44567325, 0.52929049, 0.5490053 ],
+                                   [ 0.64864341, 0.79115165, 0.96098397]]))
+
+
+class AppTestMeshgrid(BaseNumpyAppTest):
+    def test_simple(self):
+        [X, Y] = meshgrid([1, 2, 3], [4, 5, 6, 7])
+        assert all(X == array([[1, 2, 3],
+                               [1, 2, 3],
+                               [1, 2, 3],
+                               [1, 2, 3]]))
+        assert all(Y == array([[4, 4, 4],
+                               [5, 5, 5],
+                               [6, 6, 6],
+                               [7, 7, 7]]))
+
+
+class AppTestPiecewise(BaseNumpyAppTest):
+    def test_simple(self):
+        # Condition is single bool list
+        x = piecewise([0, 0], [True, False], [1])
+        assert_array_equal(x, [1, 0])
+
+        # List of conditions: single bool list
+        x = piecewise([0, 0], [[True, False]], [1])
+        assert_array_equal(x, [1, 0])
+
+        # Conditions is single bool array
+        x = piecewise([0, 0], array([True, False]), [1])
+        assert_array_equal(x, [1, 0])
+
+        # Condition is single int array
+        x = piecewise([0, 0], array([1, 0]), [1])
+        assert_array_equal(x, [1, 0])
+
+        # List of conditions: int array
+        x = piecewise([0, 0], [array([1, 0])], [1])
+        assert_array_equal(x, [1, 0])
+
+
+        x = piecewise([0, 0], [[False, True]], [lambda x:-1])
+        assert_array_equal(x, [0, -1])
+
+        x = piecewise([1, 2], [[True, False], [False, True]], [3, 4])
+        assert_array_equal(x, [3, 4])
+
+    def test_default(self):
+        # No value specified for x[1], should be 0
+        x = piecewise([1, 2], [True, False], [2])
+        assert_array_equal(x, [2, 0])
+
+        # Should set x[1] to 3
+        x = piecewise([1, 2], [True, False], [2, 3])
+        assert_array_equal(x, [2, 3])
+
+    def test_0d(self):
+        x = array(3)
+        y = piecewise(x, x > 3, [4, 0])
+        assert y.ndim == 0
+        assert y == 0
+
+
+class AppTestBincount(BaseNumpyAppTest):
+    def test_simple(self):
+        y = np.bincount(np.arange(4))
+        assert_array_equal(y, np.ones(4))
+
+    def test_simple2(self):
+        y = np.bincount(np.array([1, 5, 2, 4, 1]))
+        assert_array_equal(y, np.array([0, 2, 1, 0, 1, 1]))
+
+    def test_simple_weight(self):
+        x = np.arange(4)
+        w = np.array([0.2, 0.3, 0.5, 0.1])
+        y = np.bincount(x, w)
+        assert_array_equal(y, w)
+
+    def test_simple_weight2(self):
+        x = np.array([1, 2, 4, 5, 2])
+        w = np.array([0.2, 0.3, 0.5, 0.1, 0.2])
+        y = np.bincount(x, w)
+        assert_array_equal(y, np.array([0, 0.2, 0.5, 0, 0.5, 0.1]))
+
+    def test_with_minlength(self):
+        x = np.array([0, 1, 0, 1, 1])
+        y = np.bincount(x, minlength=3)
+        assert_array_equal(y, np.array([2, 3, 0]))
+
+    def test_with_minlength_smaller_than_maxvalue(self):
+        x = np.array([0, 1, 1, 2, 2, 3, 3])
+        y = np.bincount(x, minlength=2)
+        assert_array_equal(y, np.array([1, 2, 2, 2]))
+
+    def test_with_minlength_and_weights(self):
+        x = np.array([1, 2, 4, 5, 2])
+        w = np.array([0.2, 0.3, 0.5, 0.1, 0.2])
+        y = np.bincount(x, w, 8)
+        assert_array_equal(y, np.array([0, 0.2, 0.5, 0, 0.5, 0.1, 0, 0]))
+
+    def test_empty(self):
+        x = np.array([], dtype=int)
+        y = np.bincount(x)
+        assert_array_equal(x,y)
+
+    def test_empty_with_minlength(self):
+        x = np.array([], dtype=int)
+        y = np.bincount(x, minlength=5)
+        assert_array_equal(y, np.zeros(5, dtype=int))
+
+
+class AppTestInterp(BaseNumpyAppTest):
+    def test_exceptions(self):
+        assert_raises(ValueError, interp, 0, [], [])
+        assert_raises(ValueError, interp, 0, [0], [1, 2])
+
+    def test_basic(self):
+        x = np.linspace(0, 1, 5)
+        y = np.linspace(0, 1, 5)
+        x0 = np.linspace(0, 1, 50)
+        assert_almost_equal(np.interp(x0, x, y), x0)
+
+    def test_right_left_behavior(self):
+        assert_equal(interp([-1, 0, 1], [0], [1]), [1,1,1])
+        assert_equal(interp([-1, 0, 1], [0], [1], left=0), [0,1,1])
+        assert_equal(interp([-1, 0, 1], [0], [1], right=0), [1,1,0])
+        assert_equal(interp([-1, 0, 1], [0], [1], left=0, right=0), [0,1,0])
+
+    def test_scalar_interpolation_point(self):
+        x = np.linspace(0, 1, 5)
+        y = np.linspace(0, 1, 5)
+        x0 = 0
+        assert_almost_equal(np.interp(x0, x, y), x0)
+        x0 = .3
+        assert_almost_equal(np.interp(x0, x, y), x0)
+        x0 = np.float32(.3)
+        assert_almost_equal(np.interp(x0, x, y), x0)
+        x0 = np.float64(.3)
+        assert_almost_equal(np.interp(x0, x, y), x0)
+
+    def test_zero_dimensional_interpolation_point(self):
+        x = np.linspace(0, 1, 5)
+        y = np.linspace(0, 1, 5)
+        x0 = np.array(.3)
+        assert_almost_equal(np.interp(x0, x, y), x0)
+        x0 = np.array(.3, dtype=object)
+        assert_almost_equal(np.interp(x0, x, y), .3)
+
+
+def compare_results(res, desired):
+    for i in range(len(desired)):
+        assert_array_equal(res[i], desired[i])
+
+
+def test_percentile_list():
+    assert_equal(np.percentile([1, 2, 3], 0), 1)
+
+def test_percentile_out():
+    x = np.array([1, 2, 3])
+    y = np.zeros((3,))
+    p = (1, 2, 3)
+    np.percentile(x, p, out=y)
+    assert_equal(y, np.percentile(x, p))
+
+    x = np.array([[1, 2, 3],
+                  [4, 5, 6]])
+
+    y = np.zeros((3, 3))
+    np.percentile(x, p, axis=0, out=y)
+    assert_equal(y, np.percentile(x, p, axis=0))
+
+    y = np.zeros((3, 2))
+    np.percentile(x, p, axis=1, out=y)
+    assert_equal(y, np.percentile(x, p, axis=1))
+
+
+def test_median():
+    a0 = np.array(1)
+    a1 = np.arange(2)
+    a2 = np.arange(6).reshape(2, 3)
+    assert_allclose(np.median(a0), 1)
+    assert_allclose(np.median(a1), 0.5)
+    assert_allclose(np.median(a2), 2.5)
+    assert_allclose(np.median(a2, axis=0), [1.5,  2.5,  3.5])
+    assert_allclose(np.median(a2, axis=1), [1, 4])
+
+
+if __name__ == "__main__":
+    run_module_suite()
+'''