import itertools from numpy.testing import (assert_, assert_equal, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_allclose, assert_warns) from pytest import raises as assert_raises import pytest from numpy import mgrid, pi, sin, ogrid, poly1d, linspace import numpy as np from scipy.interpolate import (interp1d, interp2d, lagrange, PPoly, BPoly, splrep, splev, splantider, splint, sproot, Akima1DInterpolator, RegularGridInterpolator, LinearNDInterpolator, NearestNDInterpolator, RectBivariateSpline, interpn, NdPPoly, BSpline) from scipy.special import poch, gamma from scipy.interpolate import _ppoly from scipy._lib._gcutils import assert_deallocated, IS_PYPY from scipy.integrate import nquad from scipy.special import binom from scipy.sparse.sputils import matrix class TestInterp2D(object): def test_interp2d(self): y, x = mgrid[0:2:20j, 0:pi:21j] z = sin(x+0.5*y) I = interp2d(x, y, z) assert_almost_equal(I(1.0, 2.0), sin(2.0), decimal=2) v,u = ogrid[0:2:24j, 0:pi:25j] assert_almost_equal(I(u.ravel(), v.ravel()), sin(u+0.5*v), decimal=2) def test_interp2d_meshgrid_input(self): # Ticket #703 x = linspace(0, 2, 16) y = linspace(0, pi, 21) z = sin(x[None,:] + y[:,None]/2.) I = interp2d(x, y, z) assert_almost_equal(I(1.0, 2.0), sin(2.0), decimal=2) def test_interp2d_meshgrid_input_unsorted(self): np.random.seed(1234) x = linspace(0, 2, 16) y = linspace(0, pi, 21) z = sin(x[None,:] + y[:,None]/2.) ip1 = interp2d(x.copy(), y.copy(), z, kind='cubic') np.random.shuffle(x) z = sin(x[None,:] + y[:,None]/2.) ip2 = interp2d(x.copy(), y.copy(), z, kind='cubic') np.random.shuffle(x) np.random.shuffle(y) z = sin(x[None,:] + y[:,None]/2.) ip3 = interp2d(x, y, z, kind='cubic') x = linspace(0, 2, 31) y = linspace(0, pi, 30) assert_equal(ip1(x, y), ip2(x, y)) assert_equal(ip1(x, y), ip3(x, y)) def test_interp2d_eval_unsorted(self): y, x = mgrid[0:2:20j, 0:pi:21j] z = sin(x + 0.5*y) func = interp2d(x, y, z) xe = np.array([3, 4, 5]) ye = np.array([5.3, 7.1]) assert_allclose(func(xe, ye), func(xe, ye[::-1])) assert_raises(ValueError, func, xe, ye[::-1], 0, 0, True) def test_interp2d_linear(self): # Ticket #898 a = np.zeros([5, 5]) a[2, 2] = 1.0 x = y = np.arange(5) b = interp2d(x, y, a, 'linear') assert_almost_equal(b(2.0, 1.5), np.array([0.5]), decimal=2) assert_almost_equal(b(2.0, 2.5), np.array([0.5]), decimal=2) def test_interp2d_bounds(self): x = np.linspace(0, 1, 5) y = np.linspace(0, 2, 7) z = x[None, :]**2 + y[:, None] ix = np.linspace(-1, 3, 31) iy = np.linspace(-1, 3, 33) b = interp2d(x, y, z, bounds_error=True) assert_raises(ValueError, b, ix, iy) b = interp2d(x, y, z, fill_value=np.nan) iz = b(ix, iy) mx = (ix < 0) | (ix > 1) my = (iy < 0) | (iy > 2) assert_(np.isnan(iz[my,:]).all()) assert_(np.isnan(iz[:,mx]).all()) assert_(np.isfinite(iz[~my,:][:,~mx]).all()) class TestInterp1D(object): def setup_method(self): self.x5 = np.arange(5.) self.x10 = np.arange(10.) self.y10 = np.arange(10.) self.x25 = self.x10.reshape((2,5)) self.x2 = np.arange(2.) self.y2 = np.arange(2.) self.x1 = np.array([0.]) self.y1 = np.array([0.]) self.y210 = np.arange(20.).reshape((2, 10)) self.y102 = np.arange(20.).reshape((10, 2)) self.y225 = np.arange(20.).reshape((2, 2, 5)) self.y25 = np.arange(10.).reshape((2, 5)) self.y235 = np.arange(30.).reshape((2, 3, 5)) self.y325 = np.arange(30.).reshape((3, 2, 5)) self.fill_value = -100.0 def test_validation(self): # Make sure that appropriate exceptions are raised when invalid values # are given to the constructor. # These should all work. for kind in ('nearest', 'zero', 'linear', 'slinear', 'quadratic', 'cubic', 'previous', 'next'): interp1d(self.x10, self.y10, kind=kind) interp1d(self.x10, self.y10, kind=kind, fill_value="extrapolate") interp1d(self.x10, self.y10, kind='linear', fill_value=(-1, 1)) interp1d(self.x10, self.y10, kind='linear', fill_value=np.array([-1])) interp1d(self.x10, self.y10, kind='linear', fill_value=(-1,)) interp1d(self.x10, self.y10, kind='linear', fill_value=-1) interp1d(self.x10, self.y10, kind='linear', fill_value=(-1, -1)) interp1d(self.x10, self.y10, kind=0) interp1d(self.x10, self.y10, kind=1) interp1d(self.x10, self.y10, kind=2) interp1d(self.x10, self.y10, kind=3) interp1d(self.x10, self.y210, kind='linear', axis=-1, fill_value=(-1, -1)) interp1d(self.x2, self.y210, kind='linear', axis=0, fill_value=np.ones(10)) interp1d(self.x2, self.y210, kind='linear', axis=0, fill_value=(np.ones(10), np.ones(10))) interp1d(self.x2, self.y210, kind='linear', axis=0, fill_value=(np.ones(10), -1)) # x array must be 1D. assert_raises(ValueError, interp1d, self.x25, self.y10) # y array cannot be a scalar. assert_raises(ValueError, interp1d, self.x10, np.array(0)) # Check for x and y arrays having the same length. assert_raises(ValueError, interp1d, self.x10, self.y2) assert_raises(ValueError, interp1d, self.x2, self.y10) assert_raises(ValueError, interp1d, self.x10, self.y102) interp1d(self.x10, self.y210) interp1d(self.x10, self.y102, axis=0) # Check for x and y having at least 1 element. assert_raises(ValueError, interp1d, self.x1, self.y10) assert_raises(ValueError, interp1d, self.x10, self.y1) assert_raises(ValueError, interp1d, self.x1, self.y1) # Bad fill values assert_raises(ValueError, interp1d, self.x10, self.y10, kind='linear', fill_value=(-1, -1, -1)) # doesn't broadcast assert_raises(ValueError, interp1d, self.x10, self.y10, kind='linear', fill_value=[-1, -1, -1]) # doesn't broadcast assert_raises(ValueError, interp1d, self.x10, self.y10, kind='linear', fill_value=np.array((-1, -1, -1))) # doesn't broadcast assert_raises(ValueError, interp1d, self.x10, self.y10, kind='linear', fill_value=[[-1]]) # doesn't broadcast assert_raises(ValueError, interp1d, self.x10, self.y10, kind='linear', fill_value=[-1, -1]) # doesn't broadcast assert_raises(ValueError, interp1d, self.x10, self.y10, kind='linear', fill_value=np.array([])) # doesn't broadcast assert_raises(ValueError, interp1d, self.x10, self.y10, kind='linear', fill_value=()) # doesn't broadcast assert_raises(ValueError, interp1d, self.x2, self.y210, kind='linear', axis=0, fill_value=[-1, -1]) # doesn't broadcast assert_raises(ValueError, interp1d, self.x2, self.y210, kind='linear', axis=0, fill_value=(0., [-1, -1])) # above doesn't bc def test_init(self): # Check that the attributes are initialized appropriately by the # constructor. assert_(interp1d(self.x10, self.y10).copy) assert_(not interp1d(self.x10, self.y10, copy=False).copy) assert_(interp1d(self.x10, self.y10).bounds_error) assert_(not interp1d(self.x10, self.y10, bounds_error=False).bounds_error) assert_(np.isnan(interp1d(self.x10, self.y10).fill_value)) assert_equal(interp1d(self.x10, self.y10, fill_value=3.0).fill_value, 3.0) assert_equal(interp1d(self.x10, self.y10, fill_value=(1.0, 2.0)).fill_value, (1.0, 2.0)) assert_equal(interp1d(self.x10, self.y10).axis, 0) assert_equal(interp1d(self.x10, self.y210).axis, 1) assert_equal(interp1d(self.x10, self.y102, axis=0).axis, 0) assert_array_equal(interp1d(self.x10, self.y10).x, self.x10) assert_array_equal(interp1d(self.x10, self.y10).y, self.y10) assert_array_equal(interp1d(self.x10, self.y210).y, self.y210) def test_assume_sorted(self): # Check for unsorted arrays interp10 = interp1d(self.x10, self.y10) interp10_unsorted = interp1d(self.x10[::-1], self.y10[::-1]) assert_array_almost_equal(interp10_unsorted(self.x10), self.y10) assert_array_almost_equal(interp10_unsorted(1.2), np.array([1.2])) assert_array_almost_equal(interp10_unsorted([2.4, 5.6, 6.0]), interp10([2.4, 5.6, 6.0])) # Check assume_sorted keyword (defaults to False) interp10_assume_kw = interp1d(self.x10[::-1], self.y10[::-1], assume_sorted=False) assert_array_almost_equal(interp10_assume_kw(self.x10), self.y10) interp10_assume_kw2 = interp1d(self.x10[::-1], self.y10[::-1], assume_sorted=True) # Should raise an error for unsorted input if assume_sorted=True assert_raises(ValueError, interp10_assume_kw2, self.x10) # Check that if y is a 2-D array, things are still consistent interp10_y_2d = interp1d(self.x10, self.y210) interp10_y_2d_unsorted = interp1d(self.x10[::-1], self.y210[:, ::-1]) assert_array_almost_equal(interp10_y_2d(self.x10), interp10_y_2d_unsorted(self.x10)) def test_linear(self): for kind in ['linear', 'slinear']: self._check_linear(kind) def _check_linear(self, kind): # Check the actual implementation of linear interpolation. interp10 = interp1d(self.x10, self.y10, kind=kind) assert_array_almost_equal(interp10(self.x10), self.y10) assert_array_almost_equal(interp10(1.2), np.array([1.2])) assert_array_almost_equal(interp10([2.4, 5.6, 6.0]), np.array([2.4, 5.6, 6.0])) # test fill_value="extrapolate" extrapolator = interp1d(self.x10, self.y10, kind=kind, fill_value='extrapolate') assert_allclose(extrapolator([-1., 0, 9, 11]), [-1, 0, 9, 11], rtol=1e-14) opts = dict(kind=kind, fill_value='extrapolate', bounds_error=True) assert_raises(ValueError, interp1d, self.x10, self.y10, **opts) def test_linear_dtypes(self): # regression test for gh-5898, where 1D linear interpolation has been # delegated to numpy.interp for all float dtypes, and the latter was # not handling e.g. np.float128. for dtyp in np.sctypes["float"]: x = np.arange(8, dtype=dtyp) y = x yp = interp1d(x, y, kind='linear')(x) assert_equal(yp.dtype, dtyp) assert_allclose(yp, y, atol=1e-15) def test_slinear_dtypes(self): # regression test for gh-7273: 1D slinear interpolation fails with # float32 inputs dt_r = [np.float16, np.float32, np.float64] dt_rc = dt_r + [np.complex64, np.complex128] spline_kinds = ['slinear', 'zero', 'quadratic', 'cubic'] for dtx in dt_r: x = np.arange(0, 10, dtype=dtx) for dty in dt_rc: y = np.exp(-x/3.0).astype(dty) for dtn in dt_r: xnew = x.astype(dtn) for kind in spline_kinds: f = interp1d(x, y, kind=kind, bounds_error=False) assert_allclose(f(xnew), y, atol=1e-7, err_msg="%s, %s %s" % (dtx, dty, dtn)) def test_cubic(self): # Check the actual implementation of spline interpolation. interp10 = interp1d(self.x10, self.y10, kind='cubic') assert_array_almost_equal(interp10(self.x10), self.y10) assert_array_almost_equal(interp10(1.2), np.array([1.2])) assert_array_almost_equal(interp10([2.4, 5.6, 6.0]), np.array([2.4, 5.6, 6.0]),) def test_nearest(self): # Check the actual implementation of nearest-neighbour interpolation. interp10 = interp1d(self.x10, self.y10, kind='nearest') assert_array_almost_equal(interp10(self.x10), self.y10) assert_array_almost_equal(interp10(1.2), np.array(1.)) assert_array_almost_equal(interp10([2.4, 5.6, 6.0]), np.array([2., 6., 6.]),) # test fill_value="extrapolate" extrapolator = interp1d(self.x10, self.y10, kind='nearest', fill_value='extrapolate') assert_allclose(extrapolator([-1., 0, 9, 11]), [0, 0, 9, 9], rtol=1e-14) opts = dict(kind='nearest', fill_value='extrapolate', bounds_error=True) assert_raises(ValueError, interp1d, self.x10, self.y10, **opts) def test_previous(self): # Check the actual implementation of previous interpolation. interp10 = interp1d(self.x10, self.y10, kind='previous') assert_array_almost_equal(interp10(self.x10), self.y10) assert_array_almost_equal(interp10(1.2), np.array(1.)) assert_array_almost_equal(interp10([2.4, 5.6, 6.0]), np.array([2., 5., 6.]),) # test fill_value="extrapolate" extrapolator = interp1d(self.x10, self.y10, kind='previous', fill_value='extrapolate') assert_allclose(extrapolator([-1., 0, 9, 11]), [0, 0, 9, 9], rtol=1e-14) opts = dict(kind='previous', fill_value='extrapolate', bounds_error=True) assert_raises(ValueError, interp1d, self.x10, self.y10, **opts) def test_next(self): # Check the actual implementation of next interpolation. interp10 = interp1d(self.x10, self.y10, kind='next') assert_array_almost_equal(interp10(self.x10), self.y10) assert_array_almost_equal(interp10(1.2), np.array(2.)) assert_array_almost_equal(interp10([2.4, 5.6, 6.0]), np.array([3., 6., 6.]),) # test fill_value="extrapolate" extrapolator = interp1d(self.x10, self.y10, kind='next', fill_value='extrapolate') assert_allclose(extrapolator([-1., 0, 9, 11]), [0, 0, 9, 9], rtol=1e-14) opts = dict(kind='next', fill_value='extrapolate', bounds_error=True) assert_raises(ValueError, interp1d, self.x10, self.y10, **opts) def test_zero(self): # Check the actual implementation of zero-order spline interpolation. interp10 = interp1d(self.x10, self.y10, kind='zero') assert_array_almost_equal(interp10(self.x10), self.y10) assert_array_almost_equal(interp10(1.2), np.array(1.)) assert_array_almost_equal(interp10([2.4, 5.6, 6.0]), np.array([2., 5., 6.])) def _bounds_check(self, kind='linear'): # Test that our handling of out-of-bounds input is correct. extrap10 = interp1d(self.x10, self.y10, fill_value=self.fill_value, bounds_error=False, kind=kind) assert_array_equal(extrap10(11.2), np.array(self.fill_value)) assert_array_equal(extrap10(-3.4), np.array(self.fill_value)) assert_array_equal(extrap10([[[11.2], [-3.4], [12.6], [19.3]]]), np.array(self.fill_value),) assert_array_equal(extrap10._check_bounds( np.array([-1.0, 0.0, 5.0, 9.0, 11.0])), np.array([[True, False, False, False, False], [False, False, False, False, True]])) raises_bounds_error = interp1d(self.x10, self.y10, bounds_error=True, kind=kind) assert_raises(ValueError, raises_bounds_error, -1.0) assert_raises(ValueError, raises_bounds_error, 11.0) raises_bounds_error([0.0, 5.0, 9.0]) def _bounds_check_int_nan_fill(self, kind='linear'): x = np.arange(10).astype(np.int_) y = np.arange(10).astype(np.int_) c = interp1d(x, y, kind=kind, fill_value=np.nan, bounds_error=False) yi = c(x - 1) assert_(np.isnan(yi[0])) assert_array_almost_equal(yi, np.r_[np.nan, y[:-1]]) def test_bounds(self): for kind in ('linear', 'cubic', 'nearest', 'previous', 'next', 'slinear', 'zero', 'quadratic'): self._bounds_check(kind) self._bounds_check_int_nan_fill(kind) def _check_fill_value(self, kind): interp = interp1d(self.x10, self.y10, kind=kind, fill_value=(-100, 100), bounds_error=False) assert_array_almost_equal(interp(10), 100) assert_array_almost_equal(interp(-10), -100) assert_array_almost_equal(interp([-10, 10]), [-100, 100]) # Proper broadcasting: # interp along axis of length 5 # other dim=(2, 3), (3, 2), (2, 2), or (2,) # one singleton fill_value (works for all) for y in (self.y235, self.y325, self.y225, self.y25): interp = interp1d(self.x5, y, kind=kind, axis=-1, fill_value=100, bounds_error=False) assert_array_almost_equal(interp(10), 100) assert_array_almost_equal(interp(-10), 100) assert_array_almost_equal(interp([-10, 10]), 100) # singleton lower, singleton upper interp = interp1d(self.x5, y, kind=kind, axis=-1, fill_value=(-100, 100), bounds_error=False) assert_array_almost_equal(interp(10), 100) assert_array_almost_equal(interp(-10), -100) if y.ndim == 3: result = [[[-100, 100]] * y.shape[1]] * y.shape[0] else: result = [[-100, 100]] * y.shape[0] assert_array_almost_equal(interp([-10, 10]), result) # one broadcastable (3,) fill_value fill_value = [100, 200, 300] for y in (self.y325, self.y225): assert_raises(ValueError, interp1d, self.x5, y, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) interp = interp1d(self.x5, self.y235, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) assert_array_almost_equal(interp(10), [[100, 200, 300]] * 2) assert_array_almost_equal(interp(-10), [[100, 200, 300]] * 2) assert_array_almost_equal(interp([-10, 10]), [[[100, 100], [200, 200], [300, 300]]] * 2) # one broadcastable (2,) fill_value fill_value = [100, 200] assert_raises(ValueError, interp1d, self.x5, self.y235, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) for y in (self.y225, self.y325, self.y25): interp = interp1d(self.x5, y, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) result = [100, 200] if y.ndim == 3: result = [result] * y.shape[0] assert_array_almost_equal(interp(10), result) assert_array_almost_equal(interp(-10), result) result = [[100, 100], [200, 200]] if y.ndim == 3: result = [result] * y.shape[0] assert_array_almost_equal(interp([-10, 10]), result) # broadcastable (3,) lower, singleton upper fill_value = (np.array([-100, -200, -300]), 100) for y in (self.y325, self.y225): assert_raises(ValueError, interp1d, self.x5, y, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) interp = interp1d(self.x5, self.y235, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) assert_array_almost_equal(interp(10), 100) assert_array_almost_equal(interp(-10), [[-100, -200, -300]] * 2) assert_array_almost_equal(interp([-10, 10]), [[[-100, 100], [-200, 100], [-300, 100]]] * 2) # broadcastable (2,) lower, singleton upper fill_value = (np.array([-100, -200]), 100) assert_raises(ValueError, interp1d, self.x5, self.y235, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) for y in (self.y225, self.y325, self.y25): interp = interp1d(self.x5, y, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) assert_array_almost_equal(interp(10), 100) result = [-100, -200] if y.ndim == 3: result = [result] * y.shape[0] assert_array_almost_equal(interp(-10), result) result = [[-100, 100], [-200, 100]] if y.ndim == 3: result = [result] * y.shape[0] assert_array_almost_equal(interp([-10, 10]), result) # broadcastable (3,) lower, broadcastable (3,) upper fill_value = ([-100, -200, -300], [100, 200, 300]) for y in (self.y325, self.y225): assert_raises(ValueError, interp1d, self.x5, y, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) for ii in range(2): # check ndarray as well as list here if ii == 1: fill_value = tuple(np.array(f) for f in fill_value) interp = interp1d(self.x5, self.y235, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) assert_array_almost_equal(interp(10), [[100, 200, 300]] * 2) assert_array_almost_equal(interp(-10), [[-100, -200, -300]] * 2) assert_array_almost_equal(interp([-10, 10]), [[[-100, 100], [-200, 200], [-300, 300]]] * 2) # broadcastable (2,) lower, broadcastable (2,) upper fill_value = ([-100, -200], [100, 200]) assert_raises(ValueError, interp1d, self.x5, self.y235, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) for y in (self.y325, self.y225, self.y25): interp = interp1d(self.x5, y, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) result = [100, 200] if y.ndim == 3: result = [result] * y.shape[0] assert_array_almost_equal(interp(10), result) result = [-100, -200] if y.ndim == 3: result = [result] * y.shape[0] assert_array_almost_equal(interp(-10), result) result = [[-100, 100], [-200, 200]] if y.ndim == 3: result = [result] * y.shape[0] assert_array_almost_equal(interp([-10, 10]), result) # one broadcastable (2, 2) array-like fill_value = [[100, 200], [1000, 2000]] for y in (self.y235, self.y325, self.y25): assert_raises(ValueError, interp1d, self.x5, y, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) for ii in range(2): if ii == 1: fill_value = np.array(fill_value) interp = interp1d(self.x5, self.y225, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) assert_array_almost_equal(interp(10), [[100, 200], [1000, 2000]]) assert_array_almost_equal(interp(-10), [[100, 200], [1000, 2000]]) assert_array_almost_equal(interp([-10, 10]), [[[100, 100], [200, 200]], [[1000, 1000], [2000, 2000]]]) # broadcastable (2, 2) lower, broadcastable (2, 2) upper fill_value = ([[-100, -200], [-1000, -2000]], [[100, 200], [1000, 2000]]) for y in (self.y235, self.y325, self.y25): assert_raises(ValueError, interp1d, self.x5, y, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) for ii in range(2): if ii == 1: fill_value = (np.array(fill_value[0]), np.array(fill_value[1])) interp = interp1d(self.x5, self.y225, kind=kind, axis=-1, fill_value=fill_value, bounds_error=False) assert_array_almost_equal(interp(10), [[100, 200], [1000, 2000]]) assert_array_almost_equal(interp(-10), [[-100, -200], [-1000, -2000]]) assert_array_almost_equal(interp([-10, 10]), [[[-100, 100], [-200, 200]], [[-1000, 1000], [-2000, 2000]]]) def test_fill_value(self): # test that two-element fill value works for kind in ('linear', 'nearest', 'cubic', 'slinear', 'quadratic', 'zero', 'previous', 'next'): self._check_fill_value(kind) def test_fill_value_writeable(self): # backwards compat: fill_value is a public writeable attribute interp = interp1d(self.x10, self.y10, fill_value=123.0) assert_equal(interp.fill_value, 123.0) interp.fill_value = 321.0 assert_equal(interp.fill_value, 321.0) def _nd_check_interp(self, kind='linear'): # Check the behavior when the inputs and outputs are multidimensional. # Multidimensional input. interp10 = interp1d(self.x10, self.y10, kind=kind) assert_array_almost_equal(interp10(np.array([[3., 5.], [2., 7.]])), np.array([[3., 5.], [2., 7.]])) # Scalar input -> 0-dim scalar array output assert_(isinstance(interp10(1.2), np.ndarray)) assert_equal(interp10(1.2).shape, ()) # Multidimensional outputs. interp210 = interp1d(self.x10, self.y210, kind=kind) assert_array_almost_equal(interp210(1.), np.array([1., 11.])) assert_array_almost_equal(interp210(np.array([1., 2.])), np.array([[1., 2.], [11., 12.]])) interp102 = interp1d(self.x10, self.y102, axis=0, kind=kind) assert_array_almost_equal(interp102(1.), np.array([2.0, 3.0])) assert_array_almost_equal(interp102(np.array([1., 3.])), np.array([[2., 3.], [6., 7.]])) # Both at the same time! x_new = np.array([[3., 5.], [2., 7.]]) assert_array_almost_equal(interp210(x_new), np.array([[[3., 5.], [2., 7.]], [[13., 15.], [12., 17.]]])) assert_array_almost_equal(interp102(x_new), np.array([[[6., 7.], [10., 11.]], [[4., 5.], [14., 15.]]])) def _nd_check_shape(self, kind='linear'): # Check large N-D output shape a = [4, 5, 6, 7] y = np.arange(np.prod(a)).reshape(*a) for n, s in enumerate(a): x = np.arange(s) z = interp1d(x, y, axis=n, kind=kind) assert_array_almost_equal(z(x), y, err_msg=kind) x2 = np.arange(2*3*1).reshape((2,3,1)) / 12. b = list(a) b[n:n+1] = [2,3,1] assert_array_almost_equal(z(x2).shape, b, err_msg=kind) def test_nd(self): for kind in ('linear', 'cubic', 'slinear', 'quadratic', 'nearest', 'zero', 'previous', 'next'): self._nd_check_interp(kind) self._nd_check_shape(kind) def _check_complex(self, dtype=np.complex_, kind='linear'): x = np.array([1, 2.5, 3, 3.1, 4, 6.4, 7.9, 8.0, 9.5, 10]) y = x * x ** (1 + 2j) y = y.astype(dtype) # simple test c = interp1d(x, y, kind=kind) assert_array_almost_equal(y[:-1], c(x)[:-1]) # check against interpolating real+imag separately xi = np.linspace(1, 10, 31) cr = interp1d(x, y.real, kind=kind) ci = interp1d(x, y.imag, kind=kind) assert_array_almost_equal(c(xi).real, cr(xi)) assert_array_almost_equal(c(xi).imag, ci(xi)) def test_complex(self): for kind in ('linear', 'nearest', 'cubic', 'slinear', 'quadratic', 'zero', 'previous', 'next'): self._check_complex(np.complex64, kind) self._check_complex(np.complex128, kind) @pytest.mark.skipif(IS_PYPY, reason="Test not meaningful on PyPy") def test_circular_refs(self): # Test interp1d can be automatically garbage collected x = np.linspace(0, 1) y = np.linspace(0, 1) # Confirm interp can be released from memory after use with assert_deallocated(interp1d, x, y) as interp: interp([0.1, 0.2]) del interp def test_overflow_nearest(self): # Test that the x range doesn't overflow when given integers as input for kind in ('nearest', 'previous', 'next'): x = np.array([0, 50, 127], dtype=np.int8) ii = interp1d(x, x, kind=kind) assert_array_almost_equal(ii(x), x) def test_local_nans(self): # check that for local interpolation kinds (slinear, zero) a single nan # only affects its local neighborhood x = np.arange(10).astype(float) y = x.copy() y[6] = np.nan for kind in ('zero', 'slinear'): ir = interp1d(x, y, kind=kind) vals = ir([4.9, 7.0]) assert_(np.isfinite(vals).all()) def test_spline_nans(self): # Backwards compat: a single nan makes the whole spline interpolation # return nans in an array of the correct shape. And it doesn't raise, # just quiet nans because of backcompat. x = np.arange(8).astype(float) y = x.copy() yn = y.copy() yn[3] = np.nan for kind in ['quadratic', 'cubic']: ir = interp1d(x, y, kind=kind) irn = interp1d(x, yn, kind=kind) for xnew in (6, [1, 6], [[1, 6], [3, 5]]): xnew = np.asarray(xnew) out, outn = ir(x), irn(x) assert_(np.isnan(outn).all()) assert_equal(out.shape, outn.shape) def test_all_nans(self): # regression test for gh-11637: interp1d core dumps with all-nan `x` x = np.ones(10) * np.nan y = np.arange(10) with assert_raises(ValueError): interp1d(x, y, kind='cubic') def test_read_only(self): x = np.arange(0, 10) y = np.exp(-x / 3.0) xnew = np.arange(0, 9, 0.1) # Check both read-only and not read-only: for xnew_writeable in (True, False): xnew.flags.writeable = xnew_writeable x.flags.writeable = False for kind in ('linear', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic'): f = interp1d(x, y, kind=kind) vals = f(xnew) assert_(np.isfinite(vals).all()) class TestLagrange(object): def test_lagrange(self): p = poly1d([5,2,1,4,3]) xs = np.arange(len(p.coeffs)) ys = p(xs) pl = lagrange(xs,ys) assert_array_almost_equal(p.coeffs,pl.coeffs) class TestAkima1DInterpolator(object): def test_eval(self): x = np.arange(0., 11.) y = np.array([0., 2., 1., 3., 2., 6., 5.5, 5.5, 2.7, 5.1, 3.]) ak = Akima1DInterpolator(x, y) xi = np.array([0., 0.5, 1., 1.5, 2.5, 3.5, 4.5, 5.1, 6.5, 7.2, 8.6, 9.9, 10.]) yi = np.array([0., 1.375, 2., 1.5, 1.953125, 2.484375, 4.1363636363636366866103344, 5.9803623910336236590978842, 5.5067291516462386624652936, 5.2031367459745245795943447, 4.1796554159017080820603951, 3.4110386597938129327189927, 3.]) assert_allclose(ak(xi), yi) def test_eval_2d(self): x = np.arange(0., 11.) y = np.array([0., 2., 1., 3., 2., 6., 5.5, 5.5, 2.7, 5.1, 3.]) y = np.column_stack((y, 2. * y)) ak = Akima1DInterpolator(x, y) xi = np.array([0., 0.5, 1., 1.5, 2.5, 3.5, 4.5, 5.1, 6.5, 7.2, 8.6, 9.9, 10.]) yi = np.array([0., 1.375, 2., 1.5, 1.953125, 2.484375, 4.1363636363636366866103344, 5.9803623910336236590978842, 5.5067291516462386624652936, 5.2031367459745245795943447, 4.1796554159017080820603951, 3.4110386597938129327189927, 3.]) yi = np.column_stack((yi, 2. * yi)) assert_allclose(ak(xi), yi) def test_eval_3d(self): x = np.arange(0., 11.) y_ = np.array([0., 2., 1., 3., 2., 6., 5.5, 5.5, 2.7, 5.1, 3.]) y = np.empty((11, 2, 2)) y[:, 0, 0] = y_ y[:, 1, 0] = 2. * y_ y[:, 0, 1] = 3. * y_ y[:, 1, 1] = 4. * y_ ak = Akima1DInterpolator(x, y) xi = np.array([0., 0.5, 1., 1.5, 2.5, 3.5, 4.5, 5.1, 6.5, 7.2, 8.6, 9.9, 10.]) yi = np.empty((13, 2, 2)) yi_ = np.array([0., 1.375, 2., 1.5, 1.953125, 2.484375, 4.1363636363636366866103344, 5.9803623910336236590978842, 5.5067291516462386624652936, 5.2031367459745245795943447, 4.1796554159017080820603951, 3.4110386597938129327189927, 3.]) yi[:, 0, 0] = yi_ yi[:, 1, 0] = 2. * yi_ yi[:, 0, 1] = 3. * yi_ yi[:, 1, 1] = 4. * yi_ assert_allclose(ak(xi), yi) def test_degenerate_case_multidimensional(self): # This test is for issue #5683. x = np.array([0, 1, 2]) y = np.vstack((x, x**2)).T ak = Akima1DInterpolator(x, y) x_eval = np.array([0.5, 1.5]) y_eval = ak(x_eval) assert_allclose(y_eval, np.vstack((x_eval, x_eval**2)).T) def test_extend(self): x = np.arange(0., 11.) y = np.array([0., 2., 1., 3., 2., 6., 5.5, 5.5, 2.7, 5.1, 3.]) ak = Akima1DInterpolator(x, y) match = "Extending a 1-D Akima interpolator is not yet implemented" with pytest.raises(NotImplementedError, match=match): ak.extend(None, None) class TestPPolyCommon(object): # test basic functionality for PPoly and BPoly def test_sort_check(self): c = np.array([[1, 4], [2, 5], [3, 6]]) x = np.array([0, 1, 0.5]) assert_raises(ValueError, PPoly, c, x) assert_raises(ValueError, BPoly, c, x) def test_ctor_c(self): # wrong shape: `c` must be at least 2D with assert_raises(ValueError): PPoly([1, 2], [0, 1]) def test_extend(self): # Test adding new points to the piecewise polynomial np.random.seed(1234) order = 3 x = np.unique(np.r_[0, 10 * np.random.rand(30), 10]) c = 2*np.random.rand(order+1, len(x)-1, 2, 3) - 1 for cls in (PPoly, BPoly): pp = cls(c[:,:9], x[:10]) pp.extend(c[:,9:], x[10:]) pp2 = cls(c[:, 10:], x[10:]) pp2.extend(c[:, :10], x[:10]) pp3 = cls(c, x) assert_array_equal(pp.c, pp3.c) assert_array_equal(pp.x, pp3.x) assert_array_equal(pp2.c, pp3.c) assert_array_equal(pp2.x, pp3.x) def test_extend_diff_orders(self): # Test extending polynomial with different order one np.random.seed(1234) x = np.linspace(0, 1, 6) c = np.random.rand(2, 5) x2 = np.linspace(1, 2, 6) c2 = np.random.rand(4, 5) for cls in (PPoly, BPoly): pp1 = cls(c, x) pp2 = cls(c2, x2) pp_comb = cls(c, x) pp_comb.extend(c2, x2[1:]) # NB. doesn't match to pp1 at the endpoint, because pp1 is not # continuous with pp2 as we took random coefs. xi1 = np.linspace(0, 1, 300, endpoint=False) xi2 = np.linspace(1, 2, 300) assert_allclose(pp1(xi1), pp_comb(xi1)) assert_allclose(pp2(xi2), pp_comb(xi2)) def test_extend_descending(self): np.random.seed(0) order = 3 x = np.sort(np.random.uniform(0, 10, 20)) c = np.random.rand(order + 1, x.shape[0] - 1, 2, 3) for cls in (PPoly, BPoly): p = cls(c, x) p1 = cls(c[:, :9], x[:10]) p1.extend(c[:, 9:], x[10:]) p2 = cls(c[:, 10:], x[10:]) p2.extend(c[:, :10], x[:10]) assert_array_equal(p1.c, p.c) assert_array_equal(p1.x, p.x) assert_array_equal(p2.c, p.c) assert_array_equal(p2.x, p.x) def test_shape(self): np.random.seed(1234) c = np.random.rand(8, 12, 5, 6, 7) x = np.sort(np.random.rand(13)) xp = np.random.rand(3, 4) for cls in (PPoly, BPoly): p = cls(c, x) assert_equal(p(xp).shape, (3, 4, 5, 6, 7)) # 'scalars' for cls in (PPoly, BPoly): p = cls(c[..., 0, 0, 0], x) assert_equal(np.shape(p(0.5)), ()) assert_equal(np.shape(p(np.array(0.5))), ()) assert_raises(ValueError, p, np.array([[0.1, 0.2], [0.4]], dtype=object)) def test_complex_coef(self): np.random.seed(12345) x = np.sort(np.random.random(13)) c = np.random.random((8, 12)) * (1. + 0.3j) c_re, c_im = c.real, c.imag xp = np.random.random(5) for cls in (PPoly, BPoly): p, p_re, p_im = cls(c, x), cls(c_re, x), cls(c_im, x) for nu in [0, 1, 2]: assert_allclose(p(xp, nu).real, p_re(xp, nu)) assert_allclose(p(xp, nu).imag, p_im(xp, nu)) def test_axis(self): np.random.seed(12345) c = np.random.rand(3, 4, 5, 6, 7, 8) c_s = c.shape xp = np.random.random((1, 2)) for axis in (0, 1, 2, 3): m = c.shape[axis+1] x = np.sort(np.random.rand(m+1)) for cls in (PPoly, BPoly): p = cls(c, x, axis=axis) assert_equal(p.c.shape, c_s[axis:axis+2] + c_s[:axis] + c_s[axis+2:]) res = p(xp) targ_shape = c_s[:axis] + xp.shape + c_s[2+axis:] assert_equal(res.shape, targ_shape) # deriv/antideriv does not drop the axis for p1 in [cls(c, x, axis=axis).derivative(), cls(c, x, axis=axis).derivative(2), cls(c, x, axis=axis).antiderivative(), cls(c, x, axis=axis).antiderivative(2)]: assert_equal(p1.axis, p.axis) # c array needs two axes for the coefficients and intervals, so # 0 <= axis < c.ndim-1; raise otherwise for axis in (-1, 4, 5, 6): for cls in (BPoly, PPoly): assert_raises(ValueError, cls, **dict(c=c, x=x, axis=axis)) class TestPolySubclassing(object): class P(PPoly): pass class B(BPoly): pass def _make_polynomials(self): np.random.seed(1234) x = np.sort(np.random.random(3)) c = np.random.random((4, 2)) return self.P(c, x), self.B(c, x) def test_derivative(self): pp, bp = self._make_polynomials() for p in (pp, bp): pd = p.derivative() assert_equal(p.__class__, pd.__class__) ppa = pp.antiderivative() assert_equal(pp.__class__, ppa.__class__) def test_from_spline(self): np.random.seed(1234) x = np.sort(np.r_[0, np.random.rand(11), 1]) y = np.random.rand(len(x)) spl = splrep(x, y, s=0) pp = self.P.from_spline(spl) assert_equal(pp.__class__, self.P) def test_conversions(self): pp, bp = self._make_polynomials() pp1 = self.P.from_bernstein_basis(bp) assert_equal(pp1.__class__, self.P) bp1 = self.B.from_power_basis(pp) assert_equal(bp1.__class__, self.B) def test_from_derivatives(self): x = [0, 1, 2] y = [[1], [2], [3]] bp = self.B.from_derivatives(x, y) assert_equal(bp.__class__, self.B) class TestPPoly(object): def test_simple(self): c = np.array([[1, 4], [2, 5], [3, 6]]) x = np.array([0, 0.5, 1]) p = PPoly(c, x) assert_allclose(p(0.3), 1*0.3**2 + 2*0.3 + 3) assert_allclose(p(0.7), 4*(0.7-0.5)**2 + 5*(0.7-0.5) + 6) def test_periodic(self): c = np.array([[1, 4], [2, 5], [3, 6]]) x = np.array([0, 0.5, 1]) p = PPoly(c, x, extrapolate='periodic') assert_allclose(p(1.3), 1 * 0.3 ** 2 + 2 * 0.3 + 3) assert_allclose(p(-0.3), 4 * (0.7 - 0.5) ** 2 + 5 * (0.7 - 0.5) + 6) assert_allclose(p(1.3, 1), 2 * 0.3 + 2) assert_allclose(p(-0.3, 1), 8 * (0.7 - 0.5) + 5) def test_read_only(self): c = np.array([[1, 4], [2, 5], [3, 6]]) x = np.array([0, 0.5, 1]) xnew = np.array([0, 0.1, 0.2]) PPoly(c, x, extrapolate='periodic') for writeable in (True, False): x.flags.writeable = writeable f = PPoly(c, x) vals = f(xnew) assert_(np.isfinite(vals).all()) def test_descending(self): def binom_matrix(power): n = np.arange(power + 1).reshape(-1, 1) k = np.arange(power + 1) B = binom(n, k) return B[::-1, ::-1] np.random.seed(0) power = 3 for m in [10, 20, 30]: x = np.sort(np.random.uniform(0, 10, m + 1)) ca = np.random.uniform(-2, 2, size=(power + 1, m)) h = np.diff(x) h_powers = h[None, :] ** np.arange(power + 1)[::-1, None] B = binom_matrix(power) cap = ca * h_powers cdp = np.dot(B.T, cap) cd = cdp / h_powers pa = PPoly(ca, x, extrapolate=True) pd = PPoly(cd[:, ::-1], x[::-1], extrapolate=True) x_test = np.random.uniform(-10, 20, 100) assert_allclose(pa(x_test), pd(x_test), rtol=1e-13) assert_allclose(pa(x_test, 1), pd(x_test, 1), rtol=1e-13) pa_d = pa.derivative() pd_d = pd.derivative() assert_allclose(pa_d(x_test), pd_d(x_test), rtol=1e-13) # Antiderivatives won't be equal because fixing continuity is # done in the reverse order, but surely the differences should be # equal. pa_i = pa.antiderivative() pd_i = pd.antiderivative() for a, b in np.random.uniform(-10, 20, (5, 2)): int_a = pa.integrate(a, b) int_d = pd.integrate(a, b) assert_allclose(int_a, int_d, rtol=1e-13) assert_allclose(pa_i(b) - pa_i(a), pd_i(b) - pd_i(a), rtol=1e-13) roots_d = pd.roots() roots_a = pa.roots() assert_allclose(roots_a, np.sort(roots_d), rtol=1e-12) def test_multi_shape(self): c = np.random.rand(6, 2, 1, 2, 3) x = np.array([0, 0.5, 1]) p = PPoly(c, x) assert_equal(p.x.shape, x.shape) assert_equal(p.c.shape, c.shape) assert_equal(p(0.3).shape, c.shape[2:]) assert_equal(p(np.random.rand(5, 6)).shape, (5, 6) + c.shape[2:]) dp = p.derivative() assert_equal(dp.c.shape, (5, 2, 1, 2, 3)) ip = p.antiderivative() assert_equal(ip.c.shape, (7, 2, 1, 2, 3)) def test_construct_fast(self): np.random.seed(1234) c = np.array([[1, 4], [2, 5], [3, 6]], dtype=float) x = np.array([0, 0.5, 1]) p = PPoly.construct_fast(c, x) assert_allclose(p(0.3), 1*0.3**2 + 2*0.3 + 3) assert_allclose(p(0.7), 4*(0.7-0.5)**2 + 5*(0.7-0.5) + 6) def test_vs_alternative_implementations(self): np.random.seed(1234) c = np.random.rand(3, 12, 22) x = np.sort(np.r_[0, np.random.rand(11), 1]) p = PPoly(c, x) xp = np.r_[0.3, 0.5, 0.33, 0.6] expected = _ppoly_eval_1(c, x, xp) assert_allclose(p(xp), expected) expected = _ppoly_eval_2(c[:,:,0], x, xp) assert_allclose(p(xp)[:,0], expected) def test_from_spline(self): np.random.seed(1234) x = np.sort(np.r_[0, np.random.rand(11), 1]) y = np.random.rand(len(x)) spl = splrep(x, y, s=0) pp = PPoly.from_spline(spl) xi = np.linspace(0, 1, 200) assert_allclose(pp(xi), splev(xi, spl)) # make sure .from_spline accepts BSpline objects b = BSpline(*spl) ppp = PPoly.from_spline(b) assert_allclose(ppp(xi), b(xi)) # BSpline's extrapolate attribute propagates unless overridden t, c, k = spl for extrap in (None, True, False): b = BSpline(t, c, k, extrapolate=extrap) p = PPoly.from_spline(b) assert_equal(p.extrapolate, b.extrapolate) def test_derivative_simple(self): np.random.seed(1234) c = np.array([[4, 3, 2, 1]]).T dc = np.array([[3*4, 2*3, 2]]).T ddc = np.array([[2*3*4, 1*2*3]]).T x = np.array([0, 1]) pp = PPoly(c, x) dpp = PPoly(dc, x) ddpp = PPoly(ddc, x) assert_allclose(pp.derivative().c, dpp.c) assert_allclose(pp.derivative(2).c, ddpp.c) def test_derivative_eval(self): np.random.seed(1234) x = np.sort(np.r_[0, np.random.rand(11), 1]) y = np.random.rand(len(x)) spl = splrep(x, y, s=0) pp = PPoly.from_spline(spl) xi = np.linspace(0, 1, 200) for dx in range(0, 3): assert_allclose(pp(xi, dx), splev(xi, spl, dx)) def test_derivative(self): np.random.seed(1234) x = np.sort(np.r_[0, np.random.rand(11), 1]) y = np.random.rand(len(x)) spl = splrep(x, y, s=0, k=5) pp = PPoly.from_spline(spl) xi = np.linspace(0, 1, 200) for dx in range(0, 10): assert_allclose(pp(xi, dx), pp.derivative(dx)(xi), err_msg="dx=%d" % (dx,)) def test_antiderivative_of_constant(self): # https://github.com/scipy/scipy/issues/4216 p = PPoly([[1.]], [0, 1]) assert_equal(p.antiderivative().c, PPoly([[1], [0]], [0, 1]).c) assert_equal(p.antiderivative().x, PPoly([[1], [0]], [0, 1]).x) def test_antiderivative_regression_4355(self): # https://github.com/scipy/scipy/issues/4355 p = PPoly([[1., 0.5]], [0, 1, 2]) q = p.antiderivative() assert_equal(q.c, [[1, 0.5], [0, 1]]) assert_equal(q.x, [0, 1, 2]) assert_allclose(p.integrate(0, 2), 1.5) assert_allclose(q(2) - q(0), 1.5) def test_antiderivative_simple(self): np.random.seed(1234) # [ p1(x) = 3*x**2 + 2*x + 1, # p2(x) = 1.6875] c = np.array([[3, 2, 1], [0, 0, 1.6875]]).T # [ pp1(x) = x**3 + x**2 + x, # pp2(x) = 1.6875*(x - 0.25) + pp1(0.25)] ic = np.array([[1, 1, 1, 0], [0, 0, 1.6875, 0.328125]]).T # [ ppp1(x) = (1/4)*x**4 + (1/3)*x**3 + (1/2)*x**2, # ppp2(x) = (1.6875/2)*(x - 0.25)**2 + pp1(0.25)*x + ppp1(0.25)] iic = np.array([[1/4, 1/3, 1/2, 0, 0], [0, 0, 1.6875/2, 0.328125, 0.037434895833333336]]).T x = np.array([0, 0.25, 1]) pp = PPoly(c, x) ipp = pp.antiderivative() iipp = pp.antiderivative(2) iipp2 = ipp.antiderivative() assert_allclose(ipp.x, x) assert_allclose(ipp.c.T, ic.T) assert_allclose(iipp.c.T, iic.T) assert_allclose(iipp2.c.T, iic.T) def test_antiderivative_vs_derivative(self): np.random.seed(1234) x = np.linspace(0, 1, 30)**2 y = np.random.rand(len(x)) spl = splrep(x, y, s=0, k=5) pp = PPoly.from_spline(spl) for dx in range(0, 10): ipp = pp.antiderivative(dx) # check that derivative is inverse op pp2 = ipp.derivative(dx) assert_allclose(pp.c, pp2.c) # check continuity for k in range(dx): pp2 = ipp.derivative(k) r = 1e-13 endpoint = r*pp2.x[:-1] + (1 - r)*pp2.x[1:] assert_allclose(pp2(pp2.x[1:]), pp2(endpoint), rtol=1e-7, err_msg="dx=%d k=%d" % (dx, k)) def test_antiderivative_vs_spline(self): np.random.seed(1234) x = np.sort(np.r_[0, np.random.rand(11), 1]) y = np.random.rand(len(x)) spl = splrep(x, y, s=0, k=5) pp = PPoly.from_spline(spl) for dx in range(0, 10): pp2 = pp.antiderivative(dx) spl2 = splantider(spl, dx) xi = np.linspace(0, 1, 200) assert_allclose(pp2(xi), splev(xi, spl2), rtol=1e-7) def test_antiderivative_continuity(self): c = np.array([[2, 1, 2, 2], [2, 1, 3, 3]]).T x = np.array([0, 0.5, 1]) p = PPoly(c, x) ip = p.antiderivative() # check continuity assert_allclose(ip(0.5 - 1e-9), ip(0.5 + 1e-9), rtol=1e-8) # check that only lowest order coefficients were changed p2 = ip.derivative() assert_allclose(p2.c, p.c) def test_integrate(self): np.random.seed(1234) x = np.sort(np.r_[0, np.random.rand(11), 1]) y = np.random.rand(len(x)) spl = splrep(x, y, s=0, k=5) pp = PPoly.from_spline(spl) a, b = 0.3, 0.9 ig = pp.integrate(a, b) ipp = pp.antiderivative() assert_allclose(ig, ipp(b) - ipp(a)) assert_allclose(ig, splint(a, b, spl)) a, b = -0.3, 0.9 ig = pp.integrate(a, b, extrapolate=True) assert_allclose(ig, ipp(b) - ipp(a)) assert_(np.isnan(pp.integrate(a, b, extrapolate=False)).all()) def test_integrate_readonly(self): x = np.array([1, 2, 4]) c = np.array([[0., 0.], [-1., -1.], [2., -0.], [1., 2.]]) for writeable in (True, False): x.flags.writeable = writeable P = PPoly(c, x) vals = P.integrate(1, 4) assert_(np.isfinite(vals).all()) def test_integrate_periodic(self): x = np.array([1, 2, 4]) c = np.array([[0., 0.], [-1., -1.], [2., -0.], [1., 2.]]) P = PPoly(c, x, extrapolate='periodic') I = P.antiderivative() period_int = I(4) - I(1) assert_allclose(P.integrate(1, 4), period_int) assert_allclose(P.integrate(-10, -7), period_int) assert_allclose(P.integrate(-10, -4), 2 * period_int) assert_allclose(P.integrate(1.5, 2.5), I(2.5) - I(1.5)) assert_allclose(P.integrate(3.5, 5), I(2) - I(1) + I(4) - I(3.5)) assert_allclose(P.integrate(3.5 + 12, 5 + 12), I(2) - I(1) + I(4) - I(3.5)) assert_allclose(P.integrate(3.5, 5 + 12), I(2) - I(1) + I(4) - I(3.5) + 4 * period_int) assert_allclose(P.integrate(0, -1), I(2) - I(3)) assert_allclose(P.integrate(-9, -10), I(2) - I(3)) assert_allclose(P.integrate(0, -10), I(2) - I(3) - 3 * period_int) def test_roots(self): x = np.linspace(0, 1, 31)**2 y = np.sin(30*x) spl = splrep(x, y, s=0, k=3) pp = PPoly.from_spline(spl) r = pp.roots() r = r[(r >= 0 - 1e-15) & (r <= 1 + 1e-15)] assert_allclose(r, sproot(spl), atol=1e-15) def test_roots_idzero(self): # Roots for piecewise polynomials with identically zero # sections. c = np.array([[-1, 0.25], [0, 0], [-1, 0.25]]).T x = np.array([0, 0.4, 0.6, 1.0]) pp = PPoly(c, x) assert_array_equal(pp.roots(), [0.25, 0.4, np.nan, 0.6 + 0.25]) # ditto for p.solve(const) with sections identically equal const const = 2. c1 = c.copy() c1[1, :] += const pp1 = PPoly(c1, x) assert_array_equal(pp1.solve(const), [0.25, 0.4, np.nan, 0.6 + 0.25]) def test_roots_all_zero(self): # test the code path for the polynomial being identically zero everywhere c = [[0], [0]] x = [0, 1] p = PPoly(c, x) assert_array_equal(p.roots(), [0, np.nan]) assert_array_equal(p.solve(0), [0, np.nan]) assert_array_equal(p.solve(1), []) c = [[0, 0], [0, 0]] x = [0, 1, 2] p = PPoly(c, x) assert_array_equal(p.roots(), [0, np.nan, 1, np.nan]) assert_array_equal(p.solve(0), [0, np.nan, 1, np.nan]) assert_array_equal(p.solve(1), []) def test_roots_repeated(self): # Check roots repeated in multiple sections are reported only # once. # [(x + 1)**2 - 1, -x**2] ; x == 0 is a repeated root c = np.array([[1, 0, -1], [-1, 0, 0]]).T x = np.array([-1, 0, 1]) pp = PPoly(c, x) assert_array_equal(pp.roots(), [-2, 0]) assert_array_equal(pp.roots(extrapolate=False), [0]) def test_roots_discont(self): # Check that a discontinuity across zero is reported as root c = np.array([[1], [-1]]).T x = np.array([0, 0.5, 1]) pp = PPoly(c, x) assert_array_equal(pp.roots(), [0.5]) assert_array_equal(pp.roots(discontinuity=False), []) # ditto for a discontinuity across y: assert_array_equal(pp.solve(0.5), [0.5]) assert_array_equal(pp.solve(0.5, discontinuity=False), []) assert_array_equal(pp.solve(1.5), []) assert_array_equal(pp.solve(1.5, discontinuity=False), []) def test_roots_random(self): # Check high-order polynomials with random coefficients np.random.seed(1234) num = 0 for extrapolate in (True, False): for order in range(0, 20): x = np.unique(np.r_[0, 10 * np.random.rand(30), 10]) c = 2*np.random.rand(order+1, len(x)-1, 2, 3) - 1 pp = PPoly(c, x) for y in [0, np.random.random()]: r = pp.solve(y, discontinuity=False, extrapolate=extrapolate) for i in range(2): for j in range(3): rr = r[i,j] if rr.size > 0: # Check that the reported roots indeed are roots num += rr.size val = pp(rr, extrapolate=extrapolate)[:,i,j] cmpval = pp(rr, nu=1, extrapolate=extrapolate)[:,i,j] msg = "(%r) r = %s" % (extrapolate, repr(rr),) assert_allclose((val-y) / cmpval, 0, atol=1e-7, err_msg=msg) # Check that we checked a number of roots assert_(num > 100, repr(num)) def test_roots_croots(self): # Test the complex root finding algorithm np.random.seed(1234) for k in range(1, 15): c = np.random.rand(k, 1, 130) if k == 3: # add a case with zero discriminant c[:,0,0] = 1, 2, 1 for y in [0, np.random.random()]: w = np.empty(c.shape, dtype=complex) _ppoly._croots_poly1(c, w) if k == 1: assert_(np.isnan(w).all()) continue res = 0 cres = 0 for i in range(k): res += c[i,None] * w**(k-1-i) cres += abs(c[i,None] * w**(k-1-i)) with np.errstate(invalid='ignore'): res /= cres res = res.ravel() res = res[~np.isnan(res)] assert_allclose(res, 0, atol=1e-10) def test_extrapolate_attr(self): # [ 1 - x**2 ] c = np.array([[-1, 0, 1]]).T x = np.array([0, 1]) for extrapolate in [True, False, None]: pp = PPoly(c, x, extrapolate=extrapolate) pp_d = pp.derivative() pp_i = pp.antiderivative() if extrapolate is False: assert_(np.isnan(pp([-0.1, 1.1])).all()) assert_(np.isnan(pp_i([-0.1, 1.1])).all()) assert_(np.isnan(pp_d([-0.1, 1.1])).all()) assert_equal(pp.roots(), [1]) else: assert_allclose(pp([-0.1, 1.1]), [1-0.1**2, 1-1.1**2]) assert_(not np.isnan(pp_i([-0.1, 1.1])).any()) assert_(not np.isnan(pp_d([-0.1, 1.1])).any()) assert_allclose(pp.roots(), [1, -1]) class TestBPoly(object): def test_simple(self): x = [0, 1] c = [[3]] bp = BPoly(c, x) assert_allclose(bp(0.1), 3.) def test_simple2(self): x = [0, 1] c = [[3], [1]] bp = BPoly(c, x) # 3*(1-x) + 1*x assert_allclose(bp(0.1), 3*0.9 + 1.*0.1) def test_simple3(self): x = [0, 1] c = [[3], [1], [4]] bp = BPoly(c, x) # 3 * (1-x)**2 + 2 * x (1-x) + 4 * x**2 assert_allclose(bp(0.2), 3 * 0.8*0.8 + 1 * 2*0.2*0.8 + 4 * 0.2*0.2) def test_simple4(self): x = [0, 1] c = [[1], [1], [1], [2]] bp = BPoly(c, x) assert_allclose(bp(0.3), 0.7**3 + 3 * 0.7**2 * 0.3 + 3 * 0.7 * 0.3**2 + 2 * 0.3**3) def test_simple5(self): x = [0, 1] c = [[1], [1], [8], [2], [1]] bp = BPoly(c, x) assert_allclose(bp(0.3), 0.7**4 + 4 * 0.7**3 * 0.3 + 8 * 6 * 0.7**2 * 0.3**2 + 2 * 4 * 0.7 * 0.3**3 + 0.3**4) def test_periodic(self): x = [0, 1, 3] c = [[3, 0], [0, 0], [0, 2]] # [3*(1-x)**2, 2*((x-1)/2)**2] bp = BPoly(c, x, extrapolate='periodic') assert_allclose(bp(3.4), 3 * 0.6**2) assert_allclose(bp(-1.3), 2 * (0.7/2)**2) assert_allclose(bp(3.4, 1), -6 * 0.6) assert_allclose(bp(-1.3, 1), 2 * (0.7/2)) def test_descending(self): np.random.seed(0) power = 3 for m in [10, 20, 30]: x = np.sort(np.random.uniform(0, 10, m + 1)) ca = np.random.uniform(-0.1, 0.1, size=(power + 1, m)) # We need only to flip coefficients to get it right! cd = ca[::-1].copy() pa = BPoly(ca, x, extrapolate=True) pd = BPoly(cd[:, ::-1], x[::-1], extrapolate=True) x_test = np.random.uniform(-10, 20, 100) assert_allclose(pa(x_test), pd(x_test), rtol=1e-13) assert_allclose(pa(x_test, 1), pd(x_test, 1), rtol=1e-13) pa_d = pa.derivative() pd_d = pd.derivative() assert_allclose(pa_d(x_test), pd_d(x_test), rtol=1e-13) # Antiderivatives won't be equal because fixing continuity is # done in the reverse order, but surely the differences should be # equal. pa_i = pa.antiderivative() pd_i = pd.antiderivative() for a, b in np.random.uniform(-10, 20, (5, 2)): int_a = pa.integrate(a, b) int_d = pd.integrate(a, b) assert_allclose(int_a, int_d, rtol=1e-12) assert_allclose(pa_i(b) - pa_i(a), pd_i(b) - pd_i(a), rtol=1e-12) def test_multi_shape(self): c = np.random.rand(6, 2, 1, 2, 3) x = np.array([0, 0.5, 1]) p = BPoly(c, x) assert_equal(p.x.shape, x.shape) assert_equal(p.c.shape, c.shape) assert_equal(p(0.3).shape, c.shape[2:]) assert_equal(p(np.random.rand(5,6)).shape, (5,6)+c.shape[2:]) dp = p.derivative() assert_equal(dp.c.shape, (5, 2, 1, 2, 3)) def test_interval_length(self): x = [0, 2] c = [[3], [1], [4]] bp = BPoly(c, x) xval = 0.1 s = xval / 2 # s = (x - xa) / (xb - xa) assert_allclose(bp(xval), 3 * (1-s)*(1-s) + 1 * 2*s*(1-s) + 4 * s*s) def test_two_intervals(self): x = [0, 1, 3] c = [[3, 0], [0, 0], [0, 2]] bp = BPoly(c, x) # [3*(1-x)**2, 2*((x-1)/2)**2] assert_allclose(bp(0.4), 3 * 0.6*0.6) assert_allclose(bp(1.7), 2 * (0.7/2)**2) def test_extrapolate_attr(self): x = [0, 2] c = [[3], [1], [4]] bp = BPoly(c, x) for extrapolate in (True, False, None): bp = BPoly(c, x, extrapolate=extrapolate) bp_d = bp.derivative() if extrapolate is False: assert_(np.isnan(bp([-0.1, 2.1])).all()) assert_(np.isnan(bp_d([-0.1, 2.1])).all()) else: assert_(not np.isnan(bp([-0.1, 2.1])).any()) assert_(not np.isnan(bp_d([-0.1, 2.1])).any()) class TestBPolyCalculus(object): def test_derivative(self): x = [0, 1, 3] c = [[3, 0], [0, 0], [0, 2]] bp = BPoly(c, x) # [3*(1-x)**2, 2*((x-1)/2)**2] bp_der = bp.derivative() assert_allclose(bp_der(0.4), -6*(0.6)) assert_allclose(bp_der(1.7), 0.7) # derivatives in-place assert_allclose([bp(0.4, nu=1), bp(0.4, nu=2), bp(0.4, nu=3)], [-6*(1-0.4), 6., 0.]) assert_allclose([bp(1.7, nu=1), bp(1.7, nu=2), bp(1.7, nu=3)], [0.7, 1., 0]) def test_derivative_ppoly(self): # make sure it's consistent w/ power basis np.random.seed(1234) m, k = 5, 8 # number of intervals, order x = np.sort(np.random.random(m)) c = np.random.random((k, m-1)) bp = BPoly(c, x) pp = PPoly.from_bernstein_basis(bp) for d in range(k): bp = bp.derivative() pp = pp.derivative() xp = np.linspace(x[0], x[-1], 21) assert_allclose(bp(xp), pp(xp)) def test_deriv_inplace(self): np.random.seed(1234) m, k = 5, 8 # number of intervals, order x = np.sort(np.random.random(m)) c = np.random.random((k, m-1)) # test both real and complex coefficients for cc in [c.copy(), c*(1. + 2.j)]: bp = BPoly(cc, x) xp = np.linspace(x[0], x[-1], 21) for i in range(k): assert_allclose(bp(xp, i), bp.derivative(i)(xp)) def test_antiderivative_simple(self): # f(x) = x for x \in [0, 1), # (x-1)/2 for x \in [1, 3] # # antiderivative is then # F(x) = x**2 / 2 for x \in [0, 1), # 0.5*x*(x/2 - 1) + A for x \in [1, 3] # where A = 3/4 for continuity at x = 1. x = [0, 1, 3] c = [[0, 0], [1, 1]] bp = BPoly(c, x) bi = bp.antiderivative() xx = np.linspace(0, 3, 11) assert_allclose(bi(xx), np.where(xx < 1, xx**2 / 2., 0.5 * xx * (xx/2. - 1) + 3./4), atol=1e-12, rtol=1e-12) def test_der_antider(self): np.random.seed(1234) x = np.sort(np.random.random(11)) c = np.random.random((4, 10, 2, 3)) bp = BPoly(c, x) xx = np.linspace(x[0], x[-1], 100) assert_allclose(bp.antiderivative().derivative()(xx), bp(xx), atol=1e-12, rtol=1e-12) def test_antider_ppoly(self): np.random.seed(1234) x = np.sort(np.random.random(11)) c = np.random.random((4, 10, 2, 3)) bp = BPoly(c, x) pp = PPoly.from_bernstein_basis(bp) xx = np.linspace(x[0], x[-1], 10) assert_allclose(bp.antiderivative(2)(xx), pp.antiderivative(2)(xx), atol=1e-12, rtol=1e-12) def test_antider_continuous(self): np.random.seed(1234) x = np.sort(np.random.random(11)) c = np.random.random((4, 10)) bp = BPoly(c, x).antiderivative() xx = bp.x[1:-1] assert_allclose(bp(xx - 1e-14), bp(xx + 1e-14), atol=1e-12, rtol=1e-12) def test_integrate(self): np.random.seed(1234) x = np.sort(np.random.random(11)) c = np.random.random((4, 10)) bp = BPoly(c, x) pp = PPoly.from_bernstein_basis(bp) assert_allclose(bp.integrate(0, 1), pp.integrate(0, 1), atol=1e-12, rtol=1e-12) def test_integrate_extrap(self): c = [[1]] x = [0, 1] b = BPoly(c, x) # default is extrapolate=True assert_allclose(b.integrate(0, 2), 2., atol=1e-14) # .integrate argument overrides self.extrapolate b1 = BPoly(c, x, extrapolate=False) assert_(np.isnan(b1.integrate(0, 2))) assert_allclose(b1.integrate(0, 2, extrapolate=True), 2., atol=1e-14) def test_integrate_periodic(self): x = np.array([1, 2, 4]) c = np.array([[0., 0.], [-1., -1.], [2., -0.], [1., 2.]]) P = BPoly.from_power_basis(PPoly(c, x), extrapolate='periodic') I = P.antiderivative() period_int = I(4) - I(1) assert_allclose(P.integrate(1, 4), period_int) assert_allclose(P.integrate(-10, -7), period_int) assert_allclose(P.integrate(-10, -4), 2 * period_int) assert_allclose(P.integrate(1.5, 2.5), I(2.5) - I(1.5)) assert_allclose(P.integrate(3.5, 5), I(2) - I(1) + I(4) - I(3.5)) assert_allclose(P.integrate(3.5 + 12, 5 + 12), I(2) - I(1) + I(4) - I(3.5)) assert_allclose(P.integrate(3.5, 5 + 12), I(2) - I(1) + I(4) - I(3.5) + 4 * period_int) assert_allclose(P.integrate(0, -1), I(2) - I(3)) assert_allclose(P.integrate(-9, -10), I(2) - I(3)) assert_allclose(P.integrate(0, -10), I(2) - I(3) - 3 * period_int) def test_antider_neg(self): # .derivative(-nu) ==> .andiderivative(nu) and vice versa c = [[1]] x = [0, 1] b = BPoly(c, x) xx = np.linspace(0, 1, 21) assert_allclose(b.derivative(-1)(xx), b.antiderivative()(xx), atol=1e-12, rtol=1e-12) assert_allclose(b.derivative(1)(xx), b.antiderivative(-1)(xx), atol=1e-12, rtol=1e-12) class TestPolyConversions(object): def test_bp_from_pp(self): x = [0, 1, 3] c = [[3, 2], [1, 8], [4, 3]] pp = PPoly(c, x) bp = BPoly.from_power_basis(pp) pp1 = PPoly.from_bernstein_basis(bp) xp = [0.1, 1.4] assert_allclose(pp(xp), bp(xp)) assert_allclose(pp(xp), pp1(xp)) def test_bp_from_pp_random(self): np.random.seed(1234) m, k = 5, 8 # number of intervals, order x = np.sort(np.random.random(m)) c = np.random.random((k, m-1)) pp = PPoly(c, x) bp = BPoly.from_power_basis(pp) pp1 = PPoly.from_bernstein_basis(bp) xp = np.linspace(x[0], x[-1], 21) assert_allclose(pp(xp), bp(xp)) assert_allclose(pp(xp), pp1(xp)) def test_pp_from_bp(self): x = [0, 1, 3] c = [[3, 3], [1, 1], [4, 2]] bp = BPoly(c, x) pp = PPoly.from_bernstein_basis(bp) bp1 = BPoly.from_power_basis(pp) xp = [0.1, 1.4] assert_allclose(bp(xp), pp(xp)) assert_allclose(bp(xp), bp1(xp)) def test_broken_conversions(self): # regression test for gh-10597: from_power_basis only accepts PPoly etc. x = [0, 1, 3] c = [[3, 3], [1, 1], [4, 2]] pp = PPoly(c, x) with assert_raises(TypeError): PPoly.from_bernstein_basis(pp) bp = BPoly(c, x) with assert_raises(TypeError): BPoly.from_power_basis(bp) class TestBPolyFromDerivatives(object): def test_make_poly_1(self): c1 = BPoly._construct_from_derivatives(0, 1, [2], [3]) assert_allclose(c1, [2., 3.]) def test_make_poly_2(self): c1 = BPoly._construct_from_derivatives(0, 1, [1, 0], [1]) assert_allclose(c1, [1., 1., 1.]) # f'(0) = 3 c2 = BPoly._construct_from_derivatives(0, 1, [2, 3], [1]) assert_allclose(c2, [2., 7./2, 1.]) # f'(1) = 3 c3 = BPoly._construct_from_derivatives(0, 1, [2], [1, 3]) assert_allclose(c3, [2., -0.5, 1.]) def test_make_poly_3(self): # f'(0)=2, f''(0)=3 c1 = BPoly._construct_from_derivatives(0, 1, [1, 2, 3], [4]) assert_allclose(c1, [1., 5./3, 17./6, 4.]) # f'(1)=2, f''(1)=3 c2 = BPoly._construct_from_derivatives(0, 1, [1], [4, 2, 3]) assert_allclose(c2, [1., 19./6, 10./3, 4.]) # f'(0)=2, f'(1)=3 c3 = BPoly._construct_from_derivatives(0, 1, [1, 2], [4, 3]) assert_allclose(c3, [1., 5./3, 3., 4.]) def test_make_poly_12(self): np.random.seed(12345) ya = np.r_[0, np.random.random(5)] yb = np.r_[0, np.random.random(5)] c = BPoly._construct_from_derivatives(0, 1, ya, yb) pp = BPoly(c[:, None], [0, 1]) for j in range(6): assert_allclose([pp(0.), pp(1.)], [ya[j], yb[j]]) pp = pp.derivative() def test_raise_degree(self): np.random.seed(12345) x = [0, 1] k, d = 8, 5 c = np.random.random((k, 1, 2, 3, 4)) bp = BPoly(c, x) c1 = BPoly._raise_degree(c, d) bp1 = BPoly(c1, x) xp = np.linspace(0, 1, 11) assert_allclose(bp(xp), bp1(xp)) def test_xi_yi(self): assert_raises(ValueError, BPoly.from_derivatives, [0, 1], [0]) def test_coords_order(self): xi = [0, 0, 1] yi = [[0], [0], [0]] assert_raises(ValueError, BPoly.from_derivatives, xi, yi) def test_zeros(self): xi = [0, 1, 2, 3] yi = [[0, 0], [0], [0, 0], [0, 0]] # NB: will have to raise the degree pp = BPoly.from_derivatives(xi, yi) assert_(pp.c.shape == (4, 3)) ppd = pp.derivative() for xp in [0., 0.1, 1., 1.1, 1.9, 2., 2.5]: assert_allclose([pp(xp), ppd(xp)], [0., 0.]) def _make_random_mk(self, m, k): # k derivatives at each breakpoint np.random.seed(1234) xi = np.asarray([1. * j**2 for j in range(m+1)]) yi = [np.random.random(k) for j in range(m+1)] return xi, yi def test_random_12(self): m, k = 5, 12 xi, yi = self._make_random_mk(m, k) pp = BPoly.from_derivatives(xi, yi) for order in range(k//2): assert_allclose(pp(xi), [yy[order] for yy in yi]) pp = pp.derivative() def test_order_zero(self): m, k = 5, 12 xi, yi = self._make_random_mk(m, k) assert_raises(ValueError, BPoly.from_derivatives, **dict(xi=xi, yi=yi, orders=0)) def test_orders_too_high(self): m, k = 5, 12 xi, yi = self._make_random_mk(m, k) BPoly.from_derivatives(xi, yi, orders=2*k-1) # this is still ok assert_raises(ValueError, BPoly.from_derivatives, # but this is not **dict(xi=xi, yi=yi, orders=2*k)) def test_orders_global(self): m, k = 5, 12 xi, yi = self._make_random_mk(m, k) # ok, this is confusing. Local polynomials will be of the order 5 # which means that up to the 2nd derivatives will be used at each point order = 5 pp = BPoly.from_derivatives(xi, yi, orders=order) for j in range(order//2+1): assert_allclose(pp(xi[1:-1] - 1e-12), pp(xi[1:-1] + 1e-12)) pp = pp.derivative() assert_(not np.allclose(pp(xi[1:-1] - 1e-12), pp(xi[1:-1] + 1e-12))) # now repeat with `order` being even: on each interval, it uses # order//2 'derivatives' @ the right-hand endpoint and # order//2+1 @ 'derivatives' the left-hand endpoint order = 6 pp = BPoly.from_derivatives(xi, yi, orders=order) for j in range(order//2): assert_allclose(pp(xi[1:-1] - 1e-12), pp(xi[1:-1] + 1e-12)) pp = pp.derivative() assert_(not np.allclose(pp(xi[1:-1] - 1e-12), pp(xi[1:-1] + 1e-12))) def test_orders_local(self): m, k = 7, 12 xi, yi = self._make_random_mk(m, k) orders = [o + 1 for o in range(m)] for i, x in enumerate(xi[1:-1]): pp = BPoly.from_derivatives(xi, yi, orders=orders) for j in range(orders[i] // 2 + 1): assert_allclose(pp(x - 1e-12), pp(x + 1e-12)) pp = pp.derivative() assert_(not np.allclose(pp(x - 1e-12), pp(x + 1e-12))) def test_yi_trailing_dims(self): m, k = 7, 5 xi = np.sort(np.random.random(m+1)) yi = np.random.random((m+1, k, 6, 7, 8)) pp = BPoly.from_derivatives(xi, yi) assert_equal(pp.c.shape, (2*k, m, 6, 7, 8)) def test_gh_5430(self): # At least one of these raises an error unless gh-5430 is # fixed. In py2k an int is implemented using a C long, so # which one fails depends on your system. In py3k there is only # one arbitrary precision integer type, so both should fail. orders = np.int32(1) p = BPoly.from_derivatives([0, 1], [[0], [0]], orders=orders) assert_almost_equal(p(0), 0) orders = np.int64(1) p = BPoly.from_derivatives([0, 1], [[0], [0]], orders=orders) assert_almost_equal(p(0), 0) orders = 1 # This worked before; make sure it still works p = BPoly.from_derivatives([0, 1], [[0], [0]], orders=orders) assert_almost_equal(p(0), 0) orders = 1 class TestNdPPoly(object): def test_simple_1d(self): np.random.seed(1234) c = np.random.rand(4, 5) x = np.linspace(0, 1, 5+1) xi = np.random.rand(200) p = NdPPoly(c, (x,)) v1 = p((xi,)) v2 = _ppoly_eval_1(c[:,:,None], x, xi).ravel() assert_allclose(v1, v2) def test_simple_2d(self): np.random.seed(1234) c = np.random.rand(4, 5, 6, 7) x = np.linspace(0, 1, 6+1) y = np.linspace(0, 1, 7+1)**2 xi = np.random.rand(200) yi = np.random.rand(200) v1 = np.empty([len(xi), 1], dtype=c.dtype) v1.fill(np.nan) _ppoly.evaluate_nd(c.reshape(4*5, 6*7, 1), (x, y), np.array([4, 5], dtype=np.intc), np.c_[xi, yi], np.array([0, 0], dtype=np.intc), 1, v1) v1 = v1.ravel() v2 = _ppoly2d_eval(c, (x, y), xi, yi) assert_allclose(v1, v2) p = NdPPoly(c, (x, y)) for nu in (None, (0, 0), (0, 1), (1, 0), (2, 3), (9, 2)): v1 = p(np.c_[xi, yi], nu=nu) v2 = _ppoly2d_eval(c, (x, y), xi, yi, nu=nu) assert_allclose(v1, v2, err_msg=repr(nu)) def test_simple_3d(self): np.random.seed(1234) c = np.random.rand(4, 5, 6, 7, 8, 9) x = np.linspace(0, 1, 7+1) y = np.linspace(0, 1, 8+1)**2 z = np.linspace(0, 1, 9+1)**3 xi = np.random.rand(40) yi = np.random.rand(40) zi = np.random.rand(40) p = NdPPoly(c, (x, y, z)) for nu in (None, (0, 0, 0), (0, 1, 0), (1, 0, 0), (2, 3, 0), (6, 0, 2)): v1 = p((xi, yi, zi), nu=nu) v2 = _ppoly3d_eval(c, (x, y, z), xi, yi, zi, nu=nu) assert_allclose(v1, v2, err_msg=repr(nu)) def test_simple_4d(self): np.random.seed(1234) c = np.random.rand(4, 5, 6, 7, 8, 9, 10, 11) x = np.linspace(0, 1, 8+1) y = np.linspace(0, 1, 9+1)**2 z = np.linspace(0, 1, 10+1)**3 u = np.linspace(0, 1, 11+1)**4 xi = np.random.rand(20) yi = np.random.rand(20) zi = np.random.rand(20) ui = np.random.rand(20) p = NdPPoly(c, (x, y, z, u)) v1 = p((xi, yi, zi, ui)) v2 = _ppoly4d_eval(c, (x, y, z, u), xi, yi, zi, ui) assert_allclose(v1, v2) def test_deriv_1d(self): np.random.seed(1234) c = np.random.rand(4, 5) x = np.linspace(0, 1, 5+1) p = NdPPoly(c, (x,)) # derivative dp = p.derivative(nu=[1]) p1 = PPoly(c, x) dp1 = p1.derivative() assert_allclose(dp.c, dp1.c) # antiderivative dp = p.antiderivative(nu=[2]) p1 = PPoly(c, x) dp1 = p1.antiderivative(2) assert_allclose(dp.c, dp1.c) def test_deriv_3d(self): np.random.seed(1234) c = np.random.rand(4, 5, 6, 7, 8, 9) x = np.linspace(0, 1, 7+1) y = np.linspace(0, 1, 8+1)**2 z = np.linspace(0, 1, 9+1)**3 p = NdPPoly(c, (x, y, z)) # differentiate vs x p1 = PPoly(c.transpose(0, 3, 1, 2, 4, 5), x) dp = p.derivative(nu=[2]) dp1 = p1.derivative(2) assert_allclose(dp.c, dp1.c.transpose(0, 2, 3, 1, 4, 5)) # antidifferentiate vs y p1 = PPoly(c.transpose(1, 4, 0, 2, 3, 5), y) dp = p.antiderivative(nu=[0, 1, 0]) dp1 = p1.antiderivative(1) assert_allclose(dp.c, dp1.c.transpose(2, 0, 3, 4, 1, 5)) # differentiate vs z p1 = PPoly(c.transpose(2, 5, 0, 1, 3, 4), z) dp = p.derivative(nu=[0, 0, 3]) dp1 = p1.derivative(3) assert_allclose(dp.c, dp1.c.transpose(2, 3, 0, 4, 5, 1)) def test_deriv_3d_simple(self): # Integrate to obtain function x y**2 z**4 / (2! 4!) c = np.ones((1, 1, 1, 3, 4, 5)) x = np.linspace(0, 1, 3+1)**1 y = np.linspace(0, 1, 4+1)**2 z = np.linspace(0, 1, 5+1)**3 p = NdPPoly(c, (x, y, z)) ip = p.antiderivative((1, 0, 4)) ip = ip.antiderivative((0, 2, 0)) xi = np.random.rand(20) yi = np.random.rand(20) zi = np.random.rand(20) assert_allclose(ip((xi, yi, zi)), xi * yi**2 * zi**4 / (gamma(3)*gamma(5))) def test_integrate_2d(self): np.random.seed(1234) c = np.random.rand(4, 5, 16, 17) x = np.linspace(0, 1, 16+1)**1 y = np.linspace(0, 1, 17+1)**2 # make continuously differentiable so that nquad() has an # easier time c = c.transpose(0, 2, 1, 3) cx = c.reshape(c.shape[0], c.shape[1], -1).copy() _ppoly.fix_continuity(cx, x, 2) c = cx.reshape(c.shape) c = c.transpose(0, 2, 1, 3) c = c.transpose(1, 3, 0, 2) cx = c.reshape(c.shape[0], c.shape[1], -1).copy() _ppoly.fix_continuity(cx, y, 2) c = cx.reshape(c.shape) c = c.transpose(2, 0, 3, 1).copy() # Check integration p = NdPPoly(c, (x, y)) for ranges in [[(0, 1), (0, 1)], [(0, 0.5), (0, 1)], [(0, 1), (0, 0.5)], [(0.3, 0.7), (0.6, 0.2)]]: ig = p.integrate(ranges) ig2, err2 = nquad(lambda x, y: p((x, y)), ranges, opts=[dict(epsrel=1e-5, epsabs=1e-5)]*2) assert_allclose(ig, ig2, rtol=1e-5, atol=1e-5, err_msg=repr(ranges)) def test_integrate_1d(self): np.random.seed(1234) c = np.random.rand(4, 5, 6, 16, 17, 18) x = np.linspace(0, 1, 16+1)**1 y = np.linspace(0, 1, 17+1)**2 z = np.linspace(0, 1, 18+1)**3 # Check 1-D integration p = NdPPoly(c, (x, y, z)) u = np.random.rand(200) v = np.random.rand(200) a, b = 0.2, 0.7 px = p.integrate_1d(a, b, axis=0) pax = p.antiderivative((1, 0, 0)) assert_allclose(px((u, v)), pax((b, u, v)) - pax((a, u, v))) py = p.integrate_1d(a, b, axis=1) pay = p.antiderivative((0, 1, 0)) assert_allclose(py((u, v)), pay((u, b, v)) - pay((u, a, v))) pz = p.integrate_1d(a, b, axis=2) paz = p.antiderivative((0, 0, 1)) assert_allclose(pz((u, v)), paz((u, v, b)) - paz((u, v, a))) def _ppoly_eval_1(c, x, xps): """Evaluate piecewise polynomial manually""" out = np.zeros((len(xps), c.shape[2])) for i, xp in enumerate(xps): if xp < 0 or xp > 1: out[i,:] = np.nan continue j = np.searchsorted(x, xp) - 1 d = xp - x[j] assert_(x[j] <= xp < x[j+1]) r = sum(c[k,j] * d**(c.shape[0]-k-1) for k in range(c.shape[0])) out[i,:] = r return out def _ppoly_eval_2(coeffs, breaks, xnew, fill=np.nan): """Evaluate piecewise polynomial manually (another way)""" a = breaks[0] b = breaks[-1] K = coeffs.shape[0] saveshape = np.shape(xnew) xnew = np.ravel(xnew) res = np.empty_like(xnew) mask = (xnew >= a) & (xnew <= b) res[~mask] = fill xx = xnew.compress(mask) indxs = np.searchsorted(breaks, xx)-1 indxs = indxs.clip(0, len(breaks)) pp = coeffs diff = xx - breaks.take(indxs) V = np.vander(diff, N=K) values = np.array([np.dot(V[k, :], pp[:, indxs[k]]) for k in range(len(xx))]) res[mask] = values res.shape = saveshape return res def _dpow(x, y, n): """ d^n (x**y) / dx^n """ if n < 0: raise ValueError("invalid derivative order") elif n > y: return 0 else: return poch(y - n + 1, n) * x**(y - n) def _ppoly2d_eval(c, xs, xnew, ynew, nu=None): """ Straightforward evaluation of 2-D piecewise polynomial """ if nu is None: nu = (0, 0) out = np.empty((len(xnew),), dtype=c.dtype) nx, ny = c.shape[:2] for jout, (x, y) in enumerate(zip(xnew, ynew)): if not ((xs[0][0] <= x <= xs[0][-1]) and (xs[1][0] <= y <= xs[1][-1])): out[jout] = np.nan continue j1 = np.searchsorted(xs[0], x) - 1 j2 = np.searchsorted(xs[1], y) - 1 s1 = x - xs[0][j1] s2 = y - xs[1][j2] val = 0 for k1 in range(c.shape[0]): for k2 in range(c.shape[1]): val += (c[nx-k1-1,ny-k2-1,j1,j2] * _dpow(s1, k1, nu[0]) * _dpow(s2, k2, nu[1])) out[jout] = val return out def _ppoly3d_eval(c, xs, xnew, ynew, znew, nu=None): """ Straightforward evaluation of 3-D piecewise polynomial """ if nu is None: nu = (0, 0, 0) out = np.empty((len(xnew),), dtype=c.dtype) nx, ny, nz = c.shape[:3] for jout, (x, y, z) in enumerate(zip(xnew, ynew, znew)): if not ((xs[0][0] <= x <= xs[0][-1]) and (xs[1][0] <= y <= xs[1][-1]) and (xs[2][0] <= z <= xs[2][-1])): out[jout] = np.nan continue j1 = np.searchsorted(xs[0], x) - 1 j2 = np.searchsorted(xs[1], y) - 1 j3 = np.searchsorted(xs[2], z) - 1 s1 = x - xs[0][j1] s2 = y - xs[1][j2] s3 = z - xs[2][j3] val = 0 for k1 in range(c.shape[0]): for k2 in range(c.shape[1]): for k3 in range(c.shape[2]): val += (c[nx-k1-1,ny-k2-1,nz-k3-1,j1,j2,j3] * _dpow(s1, k1, nu[0]) * _dpow(s2, k2, nu[1]) * _dpow(s3, k3, nu[2])) out[jout] = val return out def _ppoly4d_eval(c, xs, xnew, ynew, znew, unew, nu=None): """ Straightforward evaluation of 4-D piecewise polynomial """ if nu is None: nu = (0, 0, 0, 0) out = np.empty((len(xnew),), dtype=c.dtype) mx, my, mz, mu = c.shape[:4] for jout, (x, y, z, u) in enumerate(zip(xnew, ynew, znew, unew)): if not ((xs[0][0] <= x <= xs[0][-1]) and (xs[1][0] <= y <= xs[1][-1]) and (xs[2][0] <= z <= xs[2][-1]) and (xs[3][0] <= u <= xs[3][-1])): out[jout] = np.nan continue j1 = np.searchsorted(xs[0], x) - 1 j2 = np.searchsorted(xs[1], y) - 1 j3 = np.searchsorted(xs[2], z) - 1 j4 = np.searchsorted(xs[3], u) - 1 s1 = x - xs[0][j1] s2 = y - xs[1][j2] s3 = z - xs[2][j3] s4 = u - xs[3][j4] val = 0 for k1 in range(c.shape[0]): for k2 in range(c.shape[1]): for k3 in range(c.shape[2]): for k4 in range(c.shape[3]): val += (c[mx-k1-1,my-k2-1,mz-k3-1,mu-k4-1,j1,j2,j3,j4] * _dpow(s1, k1, nu[0]) * _dpow(s2, k2, nu[1]) * _dpow(s3, k3, nu[2]) * _dpow(s4, k4, nu[3])) out[jout] = val return out class TestRegularGridInterpolator(object): def _get_sample_4d(self): # create a 4-D grid of 3 points in each dimension points = [(0., .5, 1.)] * 4 values = np.asarray([0., .5, 1.]) values0 = values[:, np.newaxis, np.newaxis, np.newaxis] values1 = values[np.newaxis, :, np.newaxis, np.newaxis] values2 = values[np.newaxis, np.newaxis, :, np.newaxis] values3 = values[np.newaxis, np.newaxis, np.newaxis, :] values = (values0 + values1 * 10 + values2 * 100 + values3 * 1000) return points, values def _get_sample_4d_2(self): # create another 4-D grid of 3 points in each dimension points = [(0., .5, 1.)] * 2 + [(0., 5., 10.)] * 2 values = np.asarray([0., .5, 1.]) values0 = values[:, np.newaxis, np.newaxis, np.newaxis] values1 = values[np.newaxis, :, np.newaxis, np.newaxis] values2 = values[np.newaxis, np.newaxis, :, np.newaxis] values3 = values[np.newaxis, np.newaxis, np.newaxis, :] values = (values0 + values1 * 10 + values2 * 100 + values3 * 1000) return points, values def test_list_input(self): points, values = self._get_sample_4d() sample = np.asarray([[0.1, 0.1, 1., .9], [0.2, 0.1, .45, .8], [0.5, 0.5, .5, .5]]) for method in ['linear', 'nearest']: interp = RegularGridInterpolator(points, values.tolist(), method=method) v1 = interp(sample.tolist()) interp = RegularGridInterpolator(points, values, method=method) v2 = interp(sample) assert_allclose(v1, v2) def test_complex(self): points, values = self._get_sample_4d() values = values - 2j*values sample = np.asarray([[0.1, 0.1, 1., .9], [0.2, 0.1, .45, .8], [0.5, 0.5, .5, .5]]) for method in ['linear', 'nearest']: interp = RegularGridInterpolator(points, values, method=method) rinterp = RegularGridInterpolator(points, values.real, method=method) iinterp = RegularGridInterpolator(points, values.imag, method=method) v1 = interp(sample) v2 = rinterp(sample) + 1j*iinterp(sample) assert_allclose(v1, v2) def test_linear_xi1d(self): points, values = self._get_sample_4d_2() interp = RegularGridInterpolator(points, values) sample = np.asarray([0.1, 0.1, 10., 9.]) wanted = 1001.1 assert_array_almost_equal(interp(sample), wanted) def test_linear_xi3d(self): points, values = self._get_sample_4d() interp = RegularGridInterpolator(points, values) sample = np.asarray([[0.1, 0.1, 1., .9], [0.2, 0.1, .45, .8], [0.5, 0.5, .5, .5]]) wanted = np.asarray([1001.1, 846.2, 555.5]) assert_array_almost_equal(interp(sample), wanted) def test_nearest(self): points, values = self._get_sample_4d() interp = RegularGridInterpolator(points, values, method="nearest") sample = np.asarray([0.1, 0.1, .9, .9]) wanted = 1100. assert_array_almost_equal(interp(sample), wanted) sample = np.asarray([0.1, 0.1, 0.1, 0.1]) wanted = 0. assert_array_almost_equal(interp(sample), wanted) sample = np.asarray([0., 0., 0., 0.]) wanted = 0. assert_array_almost_equal(interp(sample), wanted) sample = np.asarray([1., 1., 1., 1.]) wanted = 1111. assert_array_almost_equal(interp(sample), wanted) sample = np.asarray([0.1, 0.4, 0.6, 0.9]) wanted = 1055. assert_array_almost_equal(interp(sample), wanted) def test_linear_edges(self): points, values = self._get_sample_4d() interp = RegularGridInterpolator(points, values) sample = np.asarray([[0., 0., 0., 0.], [1., 1., 1., 1.]]) wanted = np.asarray([0., 1111.]) assert_array_almost_equal(interp(sample), wanted) def test_valid_create(self): # create a 2-D grid of 3 points in each dimension points = [(0., .5, 1.), (0., 1., .5)] values = np.asarray([0., .5, 1.]) values0 = values[:, np.newaxis] values1 = values[np.newaxis, :] values = (values0 + values1 * 10) assert_raises(ValueError, RegularGridInterpolator, points, values) points = [((0., .5, 1.), ), (0., .5, 1.)] assert_raises(ValueError, RegularGridInterpolator, points, values) points = [(0., .5, .75, 1.), (0., .5, 1.)] assert_raises(ValueError, RegularGridInterpolator, points, values) points = [(0., .5, 1.), (0., .5, 1.), (0., .5, 1.)] assert_raises(ValueError, RegularGridInterpolator, points, values) points = [(0., .5, 1.), (0., .5, 1.)] assert_raises(ValueError, RegularGridInterpolator, points, values, method="undefmethod") def test_valid_call(self): points, values = self._get_sample_4d() interp = RegularGridInterpolator(points, values) sample = np.asarray([[0., 0., 0., 0.], [1., 1., 1., 1.]]) assert_raises(ValueError, interp, sample, "undefmethod") sample = np.asarray([[0., 0., 0.], [1., 1., 1.]]) assert_raises(ValueError, interp, sample) sample = np.asarray([[0., 0., 0., 0.], [1., 1., 1., 1.1]]) assert_raises(ValueError, interp, sample) def test_out_of_bounds_extrap(self): points, values = self._get_sample_4d() interp = RegularGridInterpolator(points, values, bounds_error=False, fill_value=None) sample = np.asarray([[-.1, -.1, -.1, -.1], [1.1, 1.1, 1.1, 1.1], [21, 2.1, -1.1, -11], [2.1, 2.1, -1.1, -1.1]]) wanted = np.asarray([0., 1111., 11., 11.]) assert_array_almost_equal(interp(sample, method="nearest"), wanted) wanted = np.asarray([-111.1, 1222.1, -11068., -1186.9]) assert_array_almost_equal(interp(sample, method="linear"), wanted) def test_out_of_bounds_extrap2(self): points, values = self._get_sample_4d_2() interp = RegularGridInterpolator(points, values, bounds_error=False, fill_value=None) sample = np.asarray([[-.1, -.1, -.1, -.1], [1.1, 1.1, 1.1, 1.1], [21, 2.1, -1.1, -11], [2.1, 2.1, -1.1, -1.1]]) wanted = np.asarray([0., 11., 11., 11.]) assert_array_almost_equal(interp(sample, method="nearest"), wanted) wanted = np.asarray([-12.1, 133.1, -1069., -97.9]) assert_array_almost_equal(interp(sample, method="linear"), wanted) def test_out_of_bounds_fill(self): points, values = self._get_sample_4d() interp = RegularGridInterpolator(points, values, bounds_error=False, fill_value=np.nan) sample = np.asarray([[-.1, -.1, -.1, -.1], [1.1, 1.1, 1.1, 1.1], [2.1, 2.1, -1.1, -1.1]]) wanted = np.asarray([np.nan, np.nan, np.nan]) assert_array_almost_equal(interp(sample, method="nearest"), wanted) assert_array_almost_equal(interp(sample, method="linear"), wanted) sample = np.asarray([[0.1, 0.1, 1., .9], [0.2, 0.1, .45, .8], [0.5, 0.5, .5, .5]]) wanted = np.asarray([1001.1, 846.2, 555.5]) assert_array_almost_equal(interp(sample), wanted) def test_nearest_compare_qhull(self): points, values = self._get_sample_4d() interp = RegularGridInterpolator(points, values, method="nearest") points_qhull = itertools.product(*points) points_qhull = [p for p in points_qhull] points_qhull = np.asarray(points_qhull) values_qhull = values.reshape(-1) interp_qhull = NearestNDInterpolator(points_qhull, values_qhull) sample = np.asarray([[0.1, 0.1, 1., .9], [0.2, 0.1, .45, .8], [0.5, 0.5, .5, .5]]) assert_array_almost_equal(interp(sample), interp_qhull(sample)) def test_linear_compare_qhull(self): points, values = self._get_sample_4d() interp = RegularGridInterpolator(points, values) points_qhull = itertools.product(*points) points_qhull = [p for p in points_qhull] points_qhull = np.asarray(points_qhull) values_qhull = values.reshape(-1) interp_qhull = LinearNDInterpolator(points_qhull, values_qhull) sample = np.asarray([[0.1, 0.1, 1., .9], [0.2, 0.1, .45, .8], [0.5, 0.5, .5, .5]]) assert_array_almost_equal(interp(sample), interp_qhull(sample)) def test_duck_typed_values(self): x = np.linspace(0, 2, 5) y = np.linspace(0, 1, 7) values = MyValue((5, 7)) for method in ('nearest', 'linear'): interp = RegularGridInterpolator((x, y), values, method=method) v1 = interp([0.4, 0.7]) interp = RegularGridInterpolator((x, y), values._v, method=method) v2 = interp([0.4, 0.7]) assert_allclose(v1, v2) def test_invalid_fill_value(self): np.random.seed(1234) x = np.linspace(0, 2, 5) y = np.linspace(0, 1, 7) values = np.random.rand(5, 7) # integers can be cast to floats RegularGridInterpolator((x, y), values, fill_value=1) # complex values cannot assert_raises(ValueError, RegularGridInterpolator, (x, y), values, fill_value=1+2j) def test_fillvalue_type(self): # from #3703; test that interpolator object construction succeeds values = np.ones((10, 20, 30), dtype='>f4') points = [np.arange(n) for n in values.shape] # xi = [(1, 1, 1)] RegularGridInterpolator(points, values) RegularGridInterpolator(points, values, fill_value=0.) class MyValue(object): """ Minimal indexable object """ def __init__(self, shape): self.ndim = 2 self.shape = shape self._v = np.arange(np.prod(shape)).reshape(shape) def __getitem__(self, idx): return self._v[idx] def __array_interface__(self): return None def __array__(self): raise RuntimeError("No array representation") class TestInterpN(object): def _sample_2d_data(self): x = np.arange(1, 6) x = np.array([.5, 2., 3., 4., 5.5]) y = np.arange(1, 6) y = np.array([.5, 2., 3., 4., 5.5]) z = np.array([[1, 2, 1, 2, 1], [1, 2, 1, 2, 1], [1, 2, 3, 2, 1], [1, 2, 2, 2, 1], [1, 2, 1, 2, 1]]) return x, y, z def test_spline_2d(self): x, y, z = self._sample_2d_data() lut = RectBivariateSpline(x, y, z) xi = np.array([[1, 2.3, 5.3, 0.5, 3.3, 1.2, 3], [1, 3.3, 1.2, 4.0, 5.0, 1.0, 3]]).T assert_array_almost_equal(interpn((x, y), z, xi, method="splinef2d"), lut.ev(xi[:, 0], xi[:, 1])) def test_list_input(self): x, y, z = self._sample_2d_data() xi = np.array([[1, 2.3, 5.3, 0.5, 3.3, 1.2, 3], [1, 3.3, 1.2, 4.0, 5.0, 1.0, 3]]).T for method in ['nearest', 'linear', 'splinef2d']: v1 = interpn((x, y), z, xi, method=method) v2 = interpn((x.tolist(), y.tolist()), z.tolist(), xi.tolist(), method=method) assert_allclose(v1, v2, err_msg=method) def test_spline_2d_outofbounds(self): x = np.array([.5, 2., 3., 4., 5.5]) y = np.array([.5, 2., 3., 4., 5.5]) z = np.array([[1, 2, 1, 2, 1], [1, 2, 1, 2, 1], [1, 2, 3, 2, 1], [1, 2, 2, 2, 1], [1, 2, 1, 2, 1]]) lut = RectBivariateSpline(x, y, z) xi = np.array([[1, 2.3, 6.3, 0.5, 3.3, 1.2, 3], [1, 3.3, 1.2, -4.0, 5.0, 1.0, 3]]).T actual = interpn((x, y), z, xi, method="splinef2d", bounds_error=False, fill_value=999.99) expected = lut.ev(xi[:, 0], xi[:, 1]) expected[2:4] = 999.99 assert_array_almost_equal(actual, expected) # no extrapolation for splinef2d assert_raises(ValueError, interpn, (x, y), z, xi, method="splinef2d", bounds_error=False, fill_value=None) def _sample_4d_data(self): points = [(0., .5, 1.)] * 2 + [(0., 5., 10.)] * 2 values = np.asarray([0., .5, 1.]) values0 = values[:, np.newaxis, np.newaxis, np.newaxis] values1 = values[np.newaxis, :, np.newaxis, np.newaxis] values2 = values[np.newaxis, np.newaxis, :, np.newaxis] values3 = values[np.newaxis, np.newaxis, np.newaxis, :] values = (values0 + values1 * 10 + values2 * 100 + values3 * 1000) return points, values def test_linear_4d(self): # create a 4-D grid of 3 points in each dimension points, values = self._sample_4d_data() interp_rg = RegularGridInterpolator(points, values) sample = np.asarray([[0.1, 0.1, 10., 9.]]) wanted = interpn(points, values, sample, method="linear") assert_array_almost_equal(interp_rg(sample), wanted) def test_4d_linear_outofbounds(self): # create a 4-D grid of 3 points in each dimension points, values = self._sample_4d_data() sample = np.asarray([[0.1, -0.1, 10.1, 9.]]) wanted = 999.99 actual = interpn(points, values, sample, method="linear", bounds_error=False, fill_value=999.99) assert_array_almost_equal(actual, wanted) def test_nearest_4d(self): # create a 4-D grid of 3 points in each dimension points, values = self._sample_4d_data() interp_rg = RegularGridInterpolator(points, values, method="nearest") sample = np.asarray([[0.1, 0.1, 10., 9.]]) wanted = interpn(points, values, sample, method="nearest") assert_array_almost_equal(interp_rg(sample), wanted) def test_4d_nearest_outofbounds(self): # create a 4-D grid of 3 points in each dimension points, values = self._sample_4d_data() sample = np.asarray([[0.1, -0.1, 10.1, 9.]]) wanted = 999.99 actual = interpn(points, values, sample, method="nearest", bounds_error=False, fill_value=999.99) assert_array_almost_equal(actual, wanted) def test_xi_1d(self): # verify that 1-D xi works as expected points, values = self._sample_4d_data() sample = np.asarray([0.1, 0.1, 10., 9.]) v1 = interpn(points, values, sample, bounds_error=False) v2 = interpn(points, values, sample[None,:], bounds_error=False) assert_allclose(v1, v2) def test_xi_nd(self): # verify that higher-d xi works as expected points, values = self._sample_4d_data() np.random.seed(1234) sample = np.random.rand(2, 3, 4) v1 = interpn(points, values, sample, method='nearest', bounds_error=False) assert_equal(v1.shape, (2, 3)) v2 = interpn(points, values, sample.reshape(-1, 4), method='nearest', bounds_error=False) assert_allclose(v1, v2.reshape(v1.shape)) def test_xi_broadcast(self): # verify that the interpolators broadcast xi x, y, values = self._sample_2d_data() points = (x, y) xi = np.linspace(0, 1, 2) yi = np.linspace(0, 3, 3) for method in ['nearest', 'linear', 'splinef2d']: sample = (xi[:,None], yi[None,:]) v1 = interpn(points, values, sample, method=method, bounds_error=False) assert_equal(v1.shape, (2, 3)) xx, yy = np.meshgrid(xi, yi) sample = np.c_[xx.T.ravel(), yy.T.ravel()] v2 = interpn(points, values, sample, method=method, bounds_error=False) assert_allclose(v1, v2.reshape(v1.shape)) def test_nonscalar_values(self): # Verify that non-scalar valued values also works points, values = self._sample_4d_data() np.random.seed(1234) values = np.random.rand(3, 3, 3, 3, 6) sample = np.random.rand(7, 11, 4) for method in ['nearest', 'linear']: v = interpn(points, values, sample, method=method, bounds_error=False) assert_equal(v.shape, (7, 11, 6), err_msg=method) vs = [interpn(points, values[...,j], sample, method=method, bounds_error=False) for j in range(6)] v2 = np.array(vs).transpose(1, 2, 0) assert_allclose(v, v2, err_msg=method) # Vector-valued splines supported with fitpack assert_raises(ValueError, interpn, points, values, sample, method='splinef2d') def test_complex(self): x, y, values = self._sample_2d_data() points = (x, y) values = values - 2j*values sample = np.array([[1, 2.3, 5.3, 0.5, 3.3, 1.2, 3], [1, 3.3, 1.2, 4.0, 5.0, 1.0, 3]]).T for method in ['linear', 'nearest']: v1 = interpn(points, values, sample, method=method) v2r = interpn(points, values.real, sample, method=method) v2i = interpn(points, values.imag, sample, method=method) v2 = v2r + 1j*v2i assert_allclose(v1, v2) # Complex-valued data not supported by spline2fd assert_warns(np.ComplexWarning, interpn, points, values, sample, method='splinef2d') def test_duck_typed_values(self): x = np.linspace(0, 2, 5) y = np.linspace(0, 1, 7) values = MyValue((5, 7)) for method in ('nearest', 'linear'): v1 = interpn((x, y), values, [0.4, 0.7], method=method) v2 = interpn((x, y), values._v, [0.4, 0.7], method=method) assert_allclose(v1, v2) def test_matrix_input(self): x = np.linspace(0, 2, 5) y = np.linspace(0, 1, 7) values = matrix(np.random.rand(5, 7)) sample = np.random.rand(3, 7, 2) for method in ('nearest', 'linear', 'splinef2d'): v1 = interpn((x, y), values, sample, method=method) v2 = interpn((x, y), np.asarray(values), sample, method=method) assert_allclose(v1, v2)