Пример #1
0
 def test_deviv_integ(self):
     " p.deriv() p.integ() "
     self.assert_close(self.exp_x.integ().deriv(), self.exp_x)
     self.assert_close(self.exp_x.integ(n=2).deriv(n=2), self.exp_x)
     self.assert_close(self.exp_x.integ(n=0), self.exp_x)
     self.assert_close(self.exp_x.deriv(n=0), self.exp_x)
     self.assert_close(self.x.deriv(self.order + 2), PowerSeries([0]))
     self.assert_close(self.exp_x.deriv(),
                       PowerSeries(self.exp_x, order=self.order - 1))
     self.assert_close(self.exp_x.integ(x0=0),
                       exp(PowerSeries(self.x, order=self.order + 1)) - 1)
Пример #2
0
 def setUp(self):
     self.order = 10
     self.x = PowerSeries([0.,1.], order=self.order)
     self.x2 = PowerSeries([0., 0., 1.], order=self.order)
     self.z = PowerSeries([0+0j, 1.+0j], order=self.order)
     self.one = PowerSeries([1.], order=self.order)
     self.zero = PowerSeries([0.], order=self.order)
     coef = 1. / np.cumprod([1.] + (1. + np.arange(0., self.order+1.)).tolist())
     self.exp_x = PowerSeries(coef, order=self.order)
     osc_coef = coef * (1j)**np.arange(len(coef))
     self.cos_x = PowerSeries([xi.real for xi in osc_coef], order=self.order)
     self.sin_x = PowerSeries([xi.imag for xi in osc_coef], order=self.order)
Пример #3
0
    def test_arith(self):
        " x+y x-y x*y x/y x**2 "
        x = self.x
        y = self.exp_x
        self.assert_close(x * x, self.x2)
        self.assert_close(y / y, self.one)
        self.assert_close((y * y) / y, y)
        self.assert_close((x * y) / y, x)
        self.assert_close(y - y, self.zero)
        self.assert_close((x + y) - x, y)
        self.assert_close(x + y - x - y, self.zero)
        self.assert_close(x**2, self.x2)
        self.assert_close(y * y * y, y**3)
        self.assert_close(2**x, self.exp_x**log(2.))
        self.assert_close(y + y, 2 * y)
        self.assert_close(y + y, y * 2)
        self.assert_close(x + 2, PowerSeries([2, 1], order=self.order))
        self.assert_close(2 + x, PowerSeries([2, 1], order=self.order))
        self.assert_close(x - 2, PowerSeries([-2, 1], order=self.order))
        self.assert_close(2 - x, PowerSeries([2, -1], order=self.order))
        self.assert_close(2 * (y / 2), y)
        self.assert_close(y * (2 / y), 2 * self.one)
        self.assertEqual(y**0, 1.)
        self.assert_close(y**(-2), 1 / y / y)

        # check division where c[0] = 0
        self.assert_close(x / x, PowerSeries([1], order=self.order - 1))
        self.assert_close((x + x**2) / x,
                          PowerSeries([1, 1], order=self.order - 1))
        self.assert_close((x * x) / self.x2,
                          PowerSeries([1], order=self.order - 2))

        # check error checks
        with self.assertRaises(ZeroDivisionError):
            self.x / self.zero
Пример #4
0
 def test_constructor(self):
     " PowerSeries(c, order) "
     x = PowerSeries(1. + np.arange(2 * self.order), order=self.order)
     self.assertEqual(len(x.c), self.order + 1)
     np.testing.assert_allclose(x.c, 1. + np.arange(self.order + 1))
     x = PowerSeries(order=self.order)
     y = PowerSeries(numpy.zeros(self.order + 1, object), order=self.order)
     self.assertEqual(len(x.c), len(y.c))
     for xi, yi in zip(x.c, y.c):
         self.assertEqual(xi, yi)
     for i in range(self.order + 1):
         self.assertEqual(x.c[i], y.c[i])
     y = PowerSeries(self.exp_x)
     for i in range(self.order + 1):
         y.c[i] *= 2
     self.assert_close(y, 2 * self.exp_x)
     self.assert_close(PowerSeries(), PowerSeries([0.]))
     with self.assertRaises(ValueError):
         PowerSeries([])
     with self.assertRaises(ValueError):
         PowerSeries(order=-1)
     with self.assertRaises(ValueError):
         PowerSeries([1, 2], order=-1)
Пример #5
0
class test_powerseries(unittest.TestCase, PowerSeriesTests):
    """docstring for test_powerseries"""
    def setUp(self):
        self.order = 10
        self.x = PowerSeries([0., 1.], order=self.order)
        self.x2 = PowerSeries([0., 0., 1.], order=self.order)
        self.z = PowerSeries([0 + 0j, 1. + 0j], order=self.order)
        self.one = PowerSeries([1.], order=self.order)
        self.zero = PowerSeries([0.], order=self.order)
        coef = 1. / np.cumprod([1.] +
                               (1. + np.arange(0., self.order + 1.)).tolist())
        self.exp_x = PowerSeries(coef, order=self.order)
        osc_coef = coef * (1j)**np.arange(len(coef))
        self.cos_x = PowerSeries([xi.real for xi in osc_coef],
                                 order=self.order)
        self.sin_x = PowerSeries([xi.imag for xi in osc_coef],
                                 order=self.order)

    def test_constructor(self):
        " PowerSeries(c, order) "
        x = PowerSeries(1. + np.arange(2 * self.order), order=self.order)
        self.assertEqual(len(x.c), self.order + 1)
        np.testing.assert_allclose(x.c, 1. + np.arange(self.order + 1))
        x = PowerSeries(order=self.order)
        y = PowerSeries(numpy.zeros(self.order + 1, object), order=self.order)
        self.assertEqual(len(x.c), len(y.c))
        for xi, yi in zip(x.c, y.c):
            self.assertEqual(xi, yi)
        for i in range(self.order + 1):
            self.assertEqual(x.c[i], y.c[i])
        y = PowerSeries(self.exp_x)
        for i in range(self.order + 1):
            y.c[i] *= 2
        self.assert_close(y, 2 * self.exp_x)
        self.assert_close(PowerSeries(), PowerSeries([0.]))
        with self.assertRaises(ValueError):
            PowerSeries([])
        with self.assertRaises(ValueError):
            PowerSeries(order=-1)
        with self.assertRaises(ValueError):
            PowerSeries([1, 2], order=-1)

    def test_arith(self):
        " x+y x-y x*y x/y x**2 "
        x = self.x
        y = self.exp_x
        self.assert_close(x * x, self.x2)
        self.assert_close(y / y, self.one)
        self.assert_close((y * y) / y, y)
        self.assert_close((x * y) / y, x)
        self.assert_close(y - y, self.zero)
        self.assert_close((x + y) - x, y)
        self.assert_close(x + y - x - y, self.zero)
        self.assert_close(x**2, self.x2)
        self.assert_close((1 + x)**2., 1 + 2 * x + self.x2)
        self.assert_close(y * y * y, y**3)
        self.assert_close(2**x, self.exp_x**log(2.))
        self.assert_close(y + y, 2 * y)
        self.assert_close(y + y, y * 2)
        self.assert_close(x + 2, PowerSeries([2, 1], order=self.order))
        self.assert_close(2 + x, PowerSeries([2, 1], order=self.order))
        self.assert_close(x - 2, PowerSeries([-2, 1], order=self.order))
        self.assert_close(2 - x, PowerSeries([2, -1], order=self.order))
        self.assert_close(2 * (y / 2), y)
        self.assert_close(y * (2 / y), 2 * self.one)
        self.assertEqual(y**0, 1.)
        self.assert_close(y**(-2), 1 / y / y)

        # check division where c[0] = 0
        self.assert_close(x / x, PowerSeries([1], order=self.order - 1))
        self.assert_close((x + x**2) / x,
                          PowerSeries([1, 1], order=self.order - 1))
        self.assert_close((x * x) / self.x2,
                          PowerSeries([1], order=self.order - 2))

        # check error checks
        with self.assertRaises(ZeroDivisionError):
            self.x / self.zero

    def test_sqrt(self):
        " sqrt "
        y = self.exp_x
        self.assert_close(sqrt(y)**2, y)
        self.assert_close(sqrt(y**2), y)
        self.assert_close(sqrt(y), y**0.5)

    def test_exp(self):
        x = self.x
        y = self.exp_x
        self.assert_close(exp(x), self.exp_x)
        self.assert_close(log(exp(y)), y)
        self.assert_close(2**y, exp(log(2) * y))
        self.assert_close(y**x, exp(log(y) * x))
        self.assert_close(y**2.5, exp(log(y) * 2.5))

    def test_trig(self):
        jx = self.x * 1j
        x = self.x * (1 + 0j)
        self.assert_close(sin(x), (exp(jx) - exp(-jx)) / 2j)
        self.assert_close(cos(x), (exp(jx) + exp(-jx)) / 2)
        x = self.x
        self.assert_close(self.sin_x, sin(self.x))
        self.assert_close(self.cos_x, cos(self.x))
        self.assert_close(tan(x), sin(x) / cos(x))
        self.assert_close(cos(arccos(x)), x)
        self.assert_close(arccos(cos(1 + x)), 1 + x)
        self.assert_close(sin(arcsin(x)), x)
        self.assert_close(arcsin(sin(1 + x)), 1 + x)
        self.assert_close(tan(arctan(x)), x)
        self.assert_close(arctan(tan(1 + x)), 1 + x)

    def test_hyp(self):
        x = self.x
        self.assert_close(sinh(x), (self.exp_x - 1 / self.exp_x) / 2)
        self.assert_close(cosh(x), (self.exp_x + 1 / self.exp_x) / 2)
        self.assert_close(tanh(x), sinh(x) / cosh(x))
        self.assert_close(arcsinh(sinh(x)), x)
        self.assert_close(sinh(arcsinh(x)), x)
        self.assert_close(arccosh(cosh(2 + x)), 2 + x)
        self.assert_close(cosh(arccosh(1.25 + x)), 1.25 + x)
        self.assert_close(arctanh(tanh(0.25 + x)), 0.25 + x)
        self.assert_close(tanh(arctanh(0.25 + x)), 0.25 + x)

    def test_call(self):
        self.assert_close(self.sin_x(self.x), sin(self.x))
        f = log(1 + self.x)
        self.assert_close(self.exp_x(log(1 + self.x)), 1 + self.x)

    def test_str(self):
        " str(p) repr(p) "
        self.assertEqual(
            str(self.x),
            str(np.array([0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.])))
        y = eval(repr(self.exp_x))
        self.assert_close(y, self.exp_x)

    def test_deviv_integ(self):
        " p.deriv() p.integ() "
        self.assert_close(self.exp_x.integ().deriv(), self.exp_x)
        self.assert_close(self.exp_x.integ(n=2).deriv(n=2), self.exp_x)
        self.assert_close(self.exp_x.integ(n=0), self.exp_x)
        self.assert_close(self.exp_x.deriv(n=0), self.exp_x)
        self.assert_close(self.x.deriv(self.order + 2), PowerSeries([0]))
        self.assert_close(self.exp_x.deriv(),
                          PowerSeries(self.exp_x, order=self.order - 1))
        self.assert_close(self.exp_x.integ(x0=0),
                          exp(PowerSeries(self.x, order=self.order + 1)) - 1)
Пример #6
0
class test_powerseries(unittest.TestCase, PowerSeriesTests):
    """docstring for test_powerseries"""
    def setUp(self):
        self.order = 10
        self.x = PowerSeries([0., 1.], order=self.order)
        self.x2 = PowerSeries([0., 0., 1.], order=self.order)
        self.z = PowerSeries([0 + 0j, 1. + 0j], order=self.order)
        self.one = PowerSeries([1.], order=self.order)
        self.zero = PowerSeries([0.], order=self.order)
        coef = 1. / np.cumprod([1.] +
                               (1. + np.arange(0., self.order + 1.)).tolist())
        self.exp_x = PowerSeries(coef, order=self.order)
        osc_coef = coef * (1j)**np.arange(len(coef))
        self.cos_x = PowerSeries([xi.real for xi in osc_coef],
                                 order=self.order)
        self.sin_x = PowerSeries([xi.imag for xi in osc_coef],
                                 order=self.order)

    def test_constructor(self):
        " PowerSeries(c, order) "
        x = PowerSeries(1. + np.arange(2 * self.order), order=self.order)
        self.assertEqual(len(x.c), self.order + 1)
        np.testing.assert_allclose(x.c, 1. + np.arange(self.order + 1))
        x = PowerSeries(order=self.order)
        y = PowerSeries(numpy.zeros(self.order + 1, object), order=self.order)
        self.assertEqual(len(x.c), len(y.c))
        for xi, yi in zip(x.c, y.c):
            self.assertEqual(xi, yi)
        for i in range(self.order + 1):
            self.assertEqual(x.c[i], y.c[i])
        y = PowerSeries(self.exp_x)
        for i in range(self.order + 1):
            y.c[i] *= 2
        self.assert_close(y, 2 * self.exp_x)
        self.assertTrue(PowerSeries(order=0).c == PowerSeries([0]).c)
        with self.assertRaises(ValueError):
            PowerSeries([])
        with self.assertRaises(ValueError):
            PowerSeries(order=-1)
        with self.assertRaises(ValueError):
            PowerSeries([1, 2], order=-1)

    def test_arith(self):
        " x+y x-y x*y x/y x**2 "
        x = self.x
        y = self.exp_x
        self.assert_close(x * x, self.x2)
        self.assert_close(y / y, self.one)
        self.assert_close((y * y) / y, y)
        self.assert_close((x * y) / y, x)
        self.assert_close(y - y, self.zero)
        self.assert_close((x + y) - x, y)
        self.assert_close(x + y - x - y, self.zero)
        self.assert_close(x**2, self.x2)
        self.assert_close((1 + x)**2., 1 + 2 * x + self.x2)
        self.assert_close(y * y * y, y**3)
        self.assert_close(2**x, self.exp_x**log(2.))
        self.assert_close(y + y, 2 * y)
        self.assert_close(y + y, y * 2)
        self.assert_close(x + 2, PowerSeries([2, 1], order=self.order))
        self.assert_close(2 + x, PowerSeries([2, 1], order=self.order))
        self.assert_close(x - 2, PowerSeries([-2, 1], order=self.order))
        self.assert_close(2 - x, PowerSeries([2, -1], order=self.order))
        self.assert_close(2 * (y / 2), y)
        self.assert_close(y * (2 / y), 2 * self.one)
        self.assertEqual(y**0, 1.)
        self.assert_close(y**(-2), 1 / y / y)

        # check division where c[0] = 0
        self.assert_close(x / x, PowerSeries([1], order=self.order - 1))
        self.assert_close((x + x**2) / x,
                          PowerSeries([1, 1], order=self.order - 1))
        self.assert_close((x * x) / self.x2,
                          PowerSeries([1], order=self.order - 2))

        # check error checks
        with self.assertRaises(ZeroDivisionError):
            self.x / self.zero

    def test_sqrt(self):
        " sqrt "
        y = self.exp_x
        self.assert_close(sqrt(y)**2, y)
        self.assert_close(sqrt(y**2), y)
        self.assert_close(sqrt(y), y**0.5)

    def test_exp(self):
        x = self.x
        y = self.exp_x
        self.assert_close(exp(x), self.exp_x)
        self.assert_close(log(exp(y)), y)
        self.assert_close(2**y, exp(log(2) * y))
        self.assert_close(y**x, exp(log(y) * x))
        self.assert_close(y**2.5, exp(log(y) * 2.5))

    def test_trig(self):
        jx = self.x * 1j
        x = self.x * (1 + 0j)
        self.assert_close(sin(x), (exp(jx) - exp(-jx)) / 2j)
        self.assert_close(cos(x), (exp(jx) + exp(-jx)) / 2)
        x = self.x
        self.assert_close(self.sin_x, sin(self.x))
        self.assert_close(self.cos_x, cos(self.x))
        self.assert_close(tan(x), sin(x) / cos(x))
        self.assert_close(cos(arccos(x)), x)
        self.assert_close(arccos(cos(1 + x)), 1 + x)
        self.assert_close(sin(arcsin(x)), x)
        self.assert_close(arcsin(sin(1 + x)), 1 + x)
        self.assert_close(tan(arctan(x)), x)
        self.assert_close(arctan(tan(1 + x)), 1 + x)

    def test_hyp(self):
        x = self.x
        self.assert_close(sinh(x), (self.exp_x - 1 / self.exp_x) / 2)
        self.assert_close(cosh(x), (self.exp_x + 1 / self.exp_x) / 2)
        self.assert_close(tanh(x), sinh(x) / cosh(x))
        self.assert_close(arcsinh(sinh(x)), x)
        self.assert_close(sinh(arcsinh(x)), x)
        self.assert_close(arccosh(cosh(2 + x)), 2 + x)
        self.assert_close(cosh(arccosh(1.25 + x)), 1.25 + x)
        self.assert_close(arctanh(tanh(0.25 + x)), 0.25 + x)
        self.assert_close(tanh(arctanh(0.25 + x)), 0.25 + x)

    def test_call(self):
        self.assert_close(self.sin_x(self.x), sin(self.x))
        f = log(1 + self.x)
        self.assert_close(self.exp_x(log(1 + self.x)), 1 + self.x)

    def test_str(self):
        " str(p) repr(p) "
        self.assertEqual(
            str(self.x),
            str(np.array([0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.])))
        y = eval(repr(self.exp_x))
        self.assert_close(y, self.exp_x)

    def test_deviv_integ(self):
        " p.deriv() p.integ() "
        self.assert_close(self.exp_x.integ().deriv(), self.exp_x)
        self.assert_close(self.exp_x.integ(2).deriv(2), self.exp_x)
        self.assert_close(self.exp_x.integ(0), self.exp_x)
        self.assert_close(self.exp_x.deriv(0), self.exp_x)
        self.assertTrue(self.x.deriv(self.order + 2) == 0.0)
        self.assert_close(self.exp_x.deriv(),
                          PowerSeries(self.exp_x, order=self.order - 1))
        self.assert_close(self.exp_x.integ(x0=0),
                          exp(PowerSeries(self.x, order=self.order + 1)) - 1)

    def test_multiseries(self):
        def layout_test(m):
            ndim = 0
            c = m.c[0]
            while isinstance(c, PowerSeries):
                ndim += 1
                c = c.c[0]
            shape = ndim * (m.order + 1, )
            for idx in np.ndindex(shape):
                try:
                    m[idx]
                    if sum(idx) > m.order:
                        raise AssertionError('sum(idx) > m.order')
                except:
                    self.assertGreater(sum(idx), m.order)

        # begin
        c = np.arange(2 * 3 * 4, dtype=float)
        c.shape = (2, 3, 4)

        # check order
        m = multiseries(c.tolist(), order=3)
        assert m.order == 3
        layout_test(m)
        for ijk in np.ndindex(7, 7, 7):
            try:
                assert m[ijk] == (c[ijk] if np.all(
                    np.array(c.shape) > ijk) else 0.)
                if sum(ijk) > m.order:
                    raise AssertionError('sum(ijk) > m.order')
            except:
                self.assertGreater(sum(ijk), 3)

        # now without order; arithmetic; function evaluation
        m = multiseries(c)
        # check linear arithmetic
        c = 2 * c + c / 2
        m = 2 * m + m / 2
        c[0, 0, 0] = 13.
        m[0, 0, 0] = 13.
        assert m.order == 6
        for ijk in np.ndindex(7, 7, 7):
            try:
                assert m[ijk] == (c[ijk] if np.all(
                    np.array(c.shape) > ijk) else 0.)
                if sum(ijk) > m.order:
                    raise AssertionError('sum(ijk) > m.order')
            except:
                self.assertGreater(sum(ijk), m.order)

        def f(x, y, z):
            return sum(m[ijk] * x**ijk[0] * y**ijk[1] * z**ijk[2]
                       for ijk in np.ndindex(c.shape))

        self.assertEqual(f(1, 2, 3), m(1, 2, 3))

        # derivatives
        def Df(x, y, z):
            return [
                sum(ijk[0] * m[ijk] * x**(ijk[0] - 1) * y**ijk[1] * z**ijk[2]
                    for ijk in np.ndindex(c.shape)),
                sum(ijk[1] * m[ijk] * x**ijk[0] * y**(ijk[1] - 1) * z**ijk[2]
                    for ijk in np.ndindex(c.shape)),
                sum(ijk[2] * m[ijk] * x**ijk[0] * y**ijk[1] * z**(ijk[2] - 1)
                    for ijk in np.ndindex(c.shape)),
            ]

        self.assertEqual(Df(1, 2, 3), [
            m.deriv(1, 0, 0)(1, 2, 3),
            m.deriv(0, 1, 0)(1, 2, 3),
            m.deriv(0, 0, 1)(1, 2, 3)
        ])
        self.assertEqual(Df(1, 2, 3), [
            m.deriv(1)(1, 2, 3),
            m.deriv(0, 1)(1, 2, 3),
            m.deriv(0, 0, 1)(1, 2, 3)
        ])
        layout_test(m.deriv(1))
        self.assertEqual(m.deriv(1).order, m.order - 1)
        layout_test(m.deriv(1, 1))
        layout_test(m.deriv(1, 2, 3))
        self.assertEqual(m.deriv(1, 2, 3).order, m.order - 6)
        self.assertEqual(m.deriv(1, 1)(1, 2, 3), m.deriv(1, 1, 0)(1, 2, 3))

        def DDf(x, y, z):
            return [
                sum(ijk[0] * ijk[1] * m[ijk] * x**(ijk[0] - 1) *
                    y**(ijk[1] - 1) * z**ijk[2]
                    for ijk in np.ndindex(c.shape)),
                sum(ijk[1] * ijk[2] * m[ijk] * x**ijk[0] * y**(ijk[1] - 1) *
                    z**(ijk[2] - 1) for ijk in np.ndindex(c.shape)),
                sum(ijk[2] * ijk[0] * m[ijk] * x**(ijk[0] - 1) * y**ijk[1] *
                    z**(ijk[2] - 1) for ijk in np.ndindex(c.shape)),
            ]

        self.assertEqual(DDf(1, 2, 3), [
            m.deriv(1, 1, 0)(1, 2, 3),
            m.deriv(0, 1, 1)(1, 2, 3),
            m.deriv(1, 0, 1)(1, 2, 3)
        ])

        def D2f(x, y, z):
            return [
                sum(ijk[0] * (ijk[0] - 1) * m[ijk] * x**(ijk[0] - 2) *
                    y**ijk[1] * z**ijk[2] for ijk in np.ndindex(c.shape)),
                sum(ijk[1] * (ijk[1] - 1) * m[ijk] * x**ijk[0] *
                    y**(ijk[1] - 2) * z**ijk[2]
                    for ijk in np.ndindex(c.shape)),
                sum(ijk[2] * (ijk[2] - 1) * m[ijk] * x**ijk[0] * y**ijk[1] *
                    z**(ijk[2] - 2) for ijk in np.ndindex(c.shape)),
            ]

        self.assertEqual(D2f(1, 2, 3), [
            m.deriv(2, 0, 0)(1, 2, 3),
            m.deriv(0, 2, 0)(1, 2, 3),
            m.deriv(0, 0, 2)(1, 2, 3)
        ])
        self.assertEqual(D2f(1, 2, 3), [
            m.deriv(2)(1, 2, 3),
            m.deriv(0, 2)(1, 2, 3),
            m.deriv(0, 0, 2)(1, 2, 3)
        ])
        self.assertEqual([0., 0., 0.], [
            m.deriv(m.order + 1),
            m.deriv(0, m.order + 1),
            m.deriv(0, 0, m.order + 1)
        ])

        # derivatives undo integrals (not true of reverse)
        self.assertEqual(m(1, 2, 3), m.integ(1, 2, 3).deriv(1, 2, 3)(1, 2, 3))
        self.assertEqual(
            m(1, 2, 3),
            m.integ(1, 2, 3, x0=[3, 2, 1]).deriv(1, 2, 3)(1, 2, 3))
        self.assertEqual(m(1, 2, 3), m.integ(0, 0, 3).deriv(0, 0, 3)(1, 2, 3))
        self.assertEqual(m(1, 2, 3), m.integ(3).deriv(3, 0, 0)(1, 2, 3))

        # integrate from x0=[0,0,0]
        mm = m.integ(1, 2, 3)
        self.assertNotEqual(mm(1, 2, 3), 0)
        assert np.allclose(
            0,
            [
                mm(0, 2, 3),
                mm(1, 0, 3),
                mm(1, 2, 0),
                mm(1, 0, 0),
                mm(0, 2, 0),
                mm(0, 0, 3),
                mm(0, 0, 0)
            ],
        )
        # integrate from x0=[1,2,3]
        mm = m.integ(1, 2, 3, x0=[1, 2, 3])
        assert np.allclose(
            0,
            [
                mm(1, 2, 3),
                mm(0, 2, 3),
                mm(1, 0, 3),
                mm(1, 2, 0),
                mm(1, 0, 0),
                mm(0, 2, 0),
                mm(0, 0, 3)
            ],
        )
        assert not np.allclose(m(0, 0, 0), 0)
        assert not np.allclose(m(2, 0, 0), 0)
        assert not np.allclose(m(0, 3, 0), 0)
        assert not np.allclose(m(0, 0, 1), 0)

        # multivar
        c = np.arange(1 * 2 * 3, dtype=float)
        c.shape = (1, 2, 3)
        m = multiseries(c)
        x, y, z = multivar(3, order=m.order)
        newm = sum(c[ijk] * x**ijk[0] * y**ijk[1] * z**ijk[2]
                   for ijk in np.ndindex(c.shape))
        self.assertEqual(newm.order, m.order)
        for ijk in np.ndindex(3 * (m.order, )):
            if sum(ijk) <= m.order:
                self.assertEqual(newm[ijk], m[ijk])
        exp1 = gv.exp(x + 2 * y + z)
        exp2 = gv.exp(x + 2 * y) * gv.exp(z)
        assert np.allclose(exp1(0, 0).c, [1., 1., 0.5, 1 / 6.])
        assert exp1.order == 3 and exp2.order == 3
        assert np.allclose(exp1(0, 0).c, [1., 1., 0.5, 1 / 6.])
        for ijk in np.ndindex(3 * (exp1.order, )):
            if sum(ijk) <= m.order:
                self.assertEqual(exp1[ijk], exp2[ijk])
Пример #7
0
class test_powerseries(unittest.TestCase, PowerSeriesTests):
    """docstring for test_powerseries"""
    def setUp(self):
        self.order = 10
        self.x = PowerSeries([0.,1.], order=self.order)
        self.x2 = PowerSeries([0., 0., 1.], order=self.order)
        self.z = PowerSeries([0+0j, 1.+0j], order=self.order)
        self.one = PowerSeries([1.], order=self.order)
        self.zero = PowerSeries([0.], order=self.order)
        coef = 1. / np.cumprod([1.] + (1. + np.arange(0., self.order+1.)).tolist())
        self.exp_x = PowerSeries(coef, order=self.order)
        osc_coef = coef * (1j)**np.arange(len(coef))
        self.cos_x = PowerSeries([xi.real for xi in osc_coef], order=self.order)
        self.sin_x = PowerSeries([xi.imag for xi in osc_coef], order=self.order)

    def test_constructor(self):
        " PowerSeries(c, order) "
        x = PowerSeries(1. + np.arange(2*self.order), order=self.order)
        self.assertEqual(len(x.c), self.order + 1)
        np.testing.assert_allclose(x.c, 1. + np.arange(self.order + 1))
        x = PowerSeries(order=self.order)
        y = PowerSeries(numpy.zeros(self.order + 1, object), order=self.order)
        self.assertEqual(len(x.c), len(y.c))
        for xi, yi in zip(x.c, y.c):
            self.assertEqual(xi, yi)
        for i in range(self.order + 1):
            self.assertEqual(x.c[i], y.c[i])
        y = PowerSeries(self.exp_x)      
        for i in range(self.order + 1):
            y.c[i] *= 2
        self.assert_close(y, 2 * self.exp_x)
        self.assert_close(PowerSeries(), PowerSeries([0.]))
        with self.assertRaises(ValueError):
            PowerSeries([])
        with self.assertRaises(ValueError):
            PowerSeries(order=-1)
        with self.assertRaises(ValueError):
            PowerSeries([1,2], order=-1)

    def test_arith(self):
        " x+y x-y x*y x/y x**2 "
        x = self.x
        y = self.exp_x
        self.assert_close(x * x, self.x2)
        self.assert_close(y / y, self.one)
        self.assert_close((y * y) / y, y)
        self.assert_close((x * y) / y, x)
        self.assert_close(y - y, self.zero)
        self.assert_close((x + y) - x, y)
        self.assert_close(x + y - x - y, self.zero)
        self.assert_close(x ** 2, self.x2)
        self.assert_close(y * y * y, y ** 3)
        self.assert_close(2 ** x, self.exp_x ** log(2.))
        self.assert_close(y + y, 2 * y)
        self.assert_close(y + y, y * 2)
        self.assert_close(x + 2, PowerSeries([2, 1], order=self.order))
        self.assert_close(2 + x, PowerSeries([2, 1], order=self.order))
        self.assert_close(x - 2, PowerSeries([-2, 1], order=self.order))
        self.assert_close(2 - x, PowerSeries([2, -1], order=self.order))
        self.assert_close(2 * (y / 2), y)
        self.assert_close(y * (2 / y), 2 * self.one)
        self.assertEqual(y ** 0, 1.)
        self.assert_close(y ** (-2), 1 / y / y)

        # check division where c[0] = 0
        self.assert_close(x / x, PowerSeries([1], order=self.order - 1))
        self.assert_close((x + x ** 2) / x, PowerSeries([1, 1], order=self.order-1))
        self.assert_close((x * x) / self.x2, PowerSeries([1], order=self.order - 2))

        # check error checks
        with self.assertRaises(ZeroDivisionError):
            self.x / self.zero

    def test_sqrt(self):
        " sqrt "
        y = self.exp_x
        self.assert_close(sqrt(y) ** 2, y)
        self.assert_close(sqrt(y ** 2), y)
        self.assert_close(sqrt(y), y ** 0.5)

    def test_exp(self):
        x = self.x
        y = self.exp_x
        self.assert_close(exp(x), self.exp_x)
        self.assert_close(log(exp(y)), y)
        self.assert_close(2 ** y, exp(log(2) * y))
        self.assert_close(y ** x, exp(log(y) * x))
        self.assert_close(y ** 2.5, exp(log(y) * 2.5))

    def test_trig(self):
        jx = self.x * 1j
        x = self.x * (1+0j)
        self.assert_close(sin(x), (exp(jx) - exp(-jx))/2j)
        self.assert_close(cos(x), (exp(jx) + exp(-jx))/2)
        x = self.x
        self.assert_close(self.sin_x, sin(self.x))
        self.assert_close(self.cos_x, cos(self.x))
        self.assert_close(tan(x), sin(x) / cos(x))
        self.assert_close(cos(arccos(x)), x)
        self.assert_close(arccos(cos(1 + x)), 1 + x)
        self.assert_close(sin(arcsin(x)), x)
        self.assert_close(arcsin(sin(1 + x)), 1 + x)
        self.assert_close(tan(arctan(x)), x)
        self.assert_close(arctan(tan(1 + x)), 1 + x)

    def test_hyp(self):
        x = self.x
        self.assert_close(sinh(x), (self.exp_x - 1 / self.exp_x)/2)
        self.assert_close(cosh(x), (self.exp_x + 1 / self.exp_x)/2)
        self.assert_close(tanh(x), sinh(x) / cosh(x))
        self.assert_close(arcsinh(sinh(x)), x)
        self.assert_close(sinh(arcsinh(x)), x)
        self.assert_close(arccosh(cosh(2 + x)), 2 + x)
        self.assert_close(cosh(arccosh(1.25 + x)), 1.25 + x)
        self.assert_close(arctanh(tanh(0.25 + x)), 0.25 + x)
        self.assert_close(tanh(arctanh(0.25 + x)), 0.25 + x)

    def test_call(self):
        self.assert_close(self.sin_x(self.x), sin(self.x))
        f = log(1 + self.x)
        self.assert_close(self.exp_x(log(1 + self.x)), 1 + self.x)

    def test_str(self):
        " str(p) repr(p) "
        self.assertEqual(str(self.x), "[ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.  0.]")
        y = eval(repr(self.exp_x))
        self.assert_close(y, self.exp_x)

    def test_deviv_integ(self):
        " p.deriv() p.integ() "
        self.assert_close(self.exp_x.integ().deriv(), self.exp_x)
        self.assert_close(self.exp_x.integ(n=2).deriv(n=2), self.exp_x)
        self.assert_close(self.exp_x.integ(n=0), self.exp_x)
        self.assert_close(self.exp_x.deriv(n=0), self.exp_x)
        self.assert_close(self.x.deriv(self.order + 2), PowerSeries([0]))
        self.assert_close(
            self.exp_x.deriv(), 
            PowerSeries(self.exp_x, order=self.order - 1)
            )
        self.assert_close(
            self.exp_x.integ(x0=0), 
            exp(PowerSeries(self.x, order=self.order+1)) - 1
            )