def test_shapes_scalarvalue_derivative(self):
     P = KroghInterpolator(self.xs,self.ys)
     n = P.n
     assert_array_equal(np.shape(P.derivatives(0)), (n,))
     assert_array_equal(np.shape(P.derivatives(np.array(0))), (n,))
     assert_array_equal(np.shape(P.derivatives([0])), (n,1))
     assert_array_equal(np.shape(P.derivatives([0,1])), (n,2))

 def test_wrapper(self):
     P = KroghInterpolator(self.xs, self.ys)
     assert_almost_equal(P(self.test_xs), krogh_interpolate(self.xs, self.ys, self.test_xs))
     assert_almost_equal(P.derivative(self.test_xs, 2), krogh_interpolate(self.xs, self.ys, self.test_xs, der=2))
     assert_almost_equal(
         P.derivatives(self.test_xs, 2), krogh_interpolate(self.xs, self.ys, self.test_xs, der=[0, 1])
     )

    def test_int_inputs(self):
        # Check input args are cast correctly to floats, gh-3669
        x = [0, 234,468,702,936,1170,1404,2340,3744,6084,8424,13104,60000]
        offset_cdf = np.array([-0.95, -0.86114777, -0.8147762, -0.64072425, -0.48002351,
                               -0.34925329, -0.26503107, -0.13148093, -0.12988833, -0.12979296,
                               -0.12973574, -0.08582937, 0.05])
        f = KroghInterpolator(x, offset_cdf)

        assert_allclose(abs((f(x) - offset_cdf) / f.derivative(x, 1)), 0, atol=1e-10)

    def test_derivatives_complex(self):
        # regression test for gh-7381: krogh.derivatives(0) fails complex y
        x, y = np.array([-1, -1, 0, 1, 1]), np.array([1, 1.0j, 0, -1, 1.0j])
        func = KroghInterpolator(x, y)
        cmplx = func.derivatives(0)

        cmplx2 = (KroghInterpolator(x, y.real).derivatives(0) +
                  1j*KroghInterpolator(x, y.imag).derivatives(0))
        assert_allclose(cmplx, cmplx2, atol=1e-15)

 def test_vector(self):
     xs = [0, 1, 2]
     ys = np.array([[0, 1], [1, 0], [2, 1]])
     P = KroghInterpolator(xs, ys)
     Pi = [KroghInterpolator(xs, ys[:, i]) for i in xrange(ys.shape[1])]
     test_xs = np.linspace(-1, 3, 100)
     assert_almost_equal(P(test_xs), np.rollaxis(np.asarray([p(test_xs) for p in Pi]), -1))
     assert_almost_equal(
         P.derivatives(test_xs), np.transpose(np.asarray([p.derivatives(test_xs) for p in Pi]), (1, 2, 0))
     )

 def test_shapes_vectorvalue_derivative(self):
     P = KroghInterpolator(self.xs,np.outer(self.ys,np.arange(3)))
     n = P.n
     assert_array_equal(np.shape(P.derivatives(0)), (n,3))
     assert_array_equal(np.shape(P.derivatives([0])), (n,1,3))
     assert_array_equal(np.shape(P.derivatives([0,1])), (n,2,3))

 def test_high_derivative(self):
     P = KroghInterpolator(self.xs,self.ys)
     for i in xrange(len(self.xs),2*len(self.xs)):
         assert_almost_equal(P.derivative(self.test_xs,i),
                             np.zeros(len(self.test_xs)))

 def test_derivative(self):
     P = KroghInterpolator(self.xs,self.ys)
     m = 10
     r = P.derivatives(self.test_xs,m)
     for i in xrange(m):
         assert_almost_equal(P.derivative(self.test_xs,i),r[i])

 def test_low_derivatives(self):
     P = KroghInterpolator(self.xs,self.ys)
     D = P.derivatives(self.test_xs,len(self.xs)+2)
     for i in xrange(D.shape[0]):
         assert_almost_equal(self.true_poly.deriv(i)(self.test_xs),
                             D[i])