def test_divmod(self):
tquo = herm.Hermite([1])
trem = herm.Hermite([2])
quo, rem = divmod(self.p5, self.p1)
assert_(quo == tquo and rem == trem)
quo, rem = divmod(self.p5, [1, 2, 3])
assert_(quo == tquo and rem == trem)
quo, rem = divmod([3, 2, 3], self.p1)
assert_(quo == tquo and rem == trem)
def Hermite(z, n): ''' HermiteH[n, z] ''' coeffs = np.zeros(n + 1) coeffs[-1] = 1 return hermite.Hermite(coeffs)(z)
def hermfit(xs, ys, deg):
coeffs = herm.hermfit(xs, ys, deg)
p = herm.Hermite(coeffs)
return mkseries(xs, ys, p)
def test_roots(self):
p = herm.Hermite(herm.poly2herm([0, -1, 0, 1]), [0, 1])
res = p.roots()
tgt = [0, .5, 1]
assert_almost_equal(res, tgt)
def test_trim(self):
coef = [1, 1e-6, 1e-12, 0]
p = herm.Hermite(coef)
assert_equal(p.trim().coef, coef[:3])
assert_equal(p.trim(1e-10).coef, coef[:2])
assert_equal(p.trim(1e-5).coef, coef[:1])
def test_pow(self):
tgt = herm.Hermite([1])
for i in range(5):
res = self.p1**i
assert_(res == tgt)
tgt = tgt * self.p1
def test_mod(self):
tgt = herm.Hermite([1])
assert_((self.p4 % self.p1) == tgt)
assert_((self.p4 % [1, 2, 3]) == tgt)
assert_(([2, 2, 3] % self.p1) == tgt)
def test_floordiv(self):
tgt = herm.Hermite([1])
assert_(self.p4 // self.p1 == tgt)
assert_(self.p4 // [1, 2, 3] == tgt)
assert_([2, 2, 3] // self.p1 == tgt)
def test_mul(self):
tgt = herm.Hermite([81., 52., 82., 12., 9.])
assert_poly_almost_equal(self.p1 * self.p1, tgt)
assert_poly_almost_equal(self.p1 * [1, 2, 3], tgt)
assert_poly_almost_equal([1, 2, 3] * self.p1, tgt)
def test_sub(self):
tgt = herm.Hermite([1])
assert_(self.p4 - self.p1 == tgt)
assert_(self.p4 - [1, 2, 3] == tgt)
assert_([2, 2, 3] - self.p1 == tgt)
def test_add(self):
tgt = herm.Hermite([2, 4, 6])
assert_(self.p1 + self.p1 == tgt)
assert_(self.p1 + [1, 2, 3] == tgt)
assert_([1, 2, 3] + self.p1 == tgt)
class TestHermiteClass(TestCase):
p1 = herm.Hermite([1, 2, 3])
p2 = herm.Hermite([1, 2, 3], [0, 1])
p3 = herm.Hermite([1, 2])
p4 = herm.Hermite([2, 2, 3])
p5 = herm.Hermite([3, 2, 3])
def test_equal(self):
assert_(self.p1 == self.p1)
assert_(self.p2 == self.p2)
assert_(not self.p1 == self.p2)
assert_(not self.p1 == self.p3)
assert_(not self.p1 == [1, 2, 3])
def test_not_equal(self):
assert_(not self.p1 != self.p1)
assert_(not self.p2 != self.p2)
assert_(self.p1 != self.p2)
assert_(self.p1 != self.p3)
assert_(self.p1 != [1, 2, 3])
def test_add(self):
tgt = herm.Hermite([2, 4, 6])
assert_(self.p1 + self.p1 == tgt)
assert_(self.p1 + [1, 2, 3] == tgt)
assert_([1, 2, 3] + self.p1 == tgt)
def test_sub(self):
tgt = herm.Hermite([1])
assert_(self.p4 - self.p1 == tgt)
assert_(self.p4 - [1, 2, 3] == tgt)
assert_([2, 2, 3] - self.p1 == tgt)
def test_mul(self):
tgt = herm.Hermite([81., 52., 82., 12., 9.])
assert_poly_almost_equal(self.p1 * self.p1, tgt)
assert_poly_almost_equal(self.p1 * [1, 2, 3], tgt)
assert_poly_almost_equal([1, 2, 3] * self.p1, tgt)
def test_floordiv(self):
tgt = herm.Hermite([1])
assert_(self.p4 // self.p1 == tgt)
assert_(self.p4 // [1, 2, 3] == tgt)
assert_([2, 2, 3] // self.p1 == tgt)
def test_mod(self):
tgt = herm.Hermite([1])
assert_((self.p4 % self.p1) == tgt)
assert_((self.p4 % [1, 2, 3]) == tgt)
assert_(([2, 2, 3] % self.p1) == tgt)
def test_divmod(self):
tquo = herm.Hermite([1])
trem = herm.Hermite([2])
quo, rem = divmod(self.p5, self.p1)
assert_(quo == tquo and rem == trem)
quo, rem = divmod(self.p5, [1, 2, 3])
assert_(quo == tquo and rem == trem)
quo, rem = divmod([3, 2, 3], self.p1)
assert_(quo == tquo and rem == trem)
def test_pow(self):
tgt = herm.Hermite([1])
for i in range(5):
res = self.p1**i
assert_(res == tgt)
tgt = tgt * self.p1
def test_call(self):
# domain = [-1, 1]
x = np.linspace(-1, 1)
tgt = 3 * (4 * x**2 - 2) + 2 * (2 * x) + 1
assert_almost_equal(self.p1(x), tgt)
# domain = [0, 1]
x = np.linspace(0, 1)
xx = 2 * x - 1
assert_almost_equal(self.p2(x), self.p1(xx))
def test_degree(self):
assert_equal(self.p1.degree(), 2)
def test_cutdeg(self):
assert_raises(ValueError, self.p1.cutdeg, .5)
assert_raises(ValueError, self.p1.cutdeg, -1)
assert_equal(len(self.p1.cutdeg(3)), 3)
assert_equal(len(self.p1.cutdeg(2)), 3)
assert_equal(len(self.p1.cutdeg(1)), 2)
assert_equal(len(self.p1.cutdeg(0)), 1)
def test_convert(self):
x = np.linspace(-1, 1)
p = self.p1.convert(domain=[0, 1])
assert_almost_equal(p(x), self.p1(x))
def test_mapparms(self):
parms = self.p2.mapparms()
assert_almost_equal(parms, [-1, 2])
def test_trim(self):
coef = [1, 1e-6, 1e-12, 0]
p = herm.Hermite(coef)
assert_equal(p.trim().coef, coef[:3])
assert_equal(p.trim(1e-10).coef, coef[:2])
assert_equal(p.trim(1e-5).coef, coef[:1])
def test_truncate(self):
assert_raises(ValueError, self.p1.truncate, .5)
assert_raises(ValueError, self.p1.truncate, 0)
assert_equal(len(self.p1.truncate(4)), 3)
assert_equal(len(self.p1.truncate(3)), 3)
assert_equal(len(self.p1.truncate(2)), 2)
assert_equal(len(self.p1.truncate(1)), 1)
def test_copy(self):
p = self.p1.copy()
assert_(self.p1 == p)
def test_integ(self):
p = self.p2.integ()
assert_almost_equal(p.coef, herm.hermint([1, 2, 3], 1, 0, scl=.5))
p = self.p2.integ(lbnd=0)
assert_almost_equal(p(0), 0)
p = self.p2.integ(1, 1)
assert_almost_equal(p.coef, herm.hermint([1, 2, 3], 1, 1, scl=.5))
p = self.p2.integ(2, [1, 2])
assert_almost_equal(p.coef, herm.hermint([1, 2, 3], 2, [1, 2], scl=.5))
def test_deriv(self):
p = self.p2.integ(2, [1, 2])
assert_almost_equal(p.deriv(1).coef, self.p2.integ(1, [1]).coef)
assert_almost_equal(p.deriv(2).coef, self.p2.coef)
def test_roots(self):
p = herm.Hermite(herm.poly2herm([0, -1, 0, 1]), [0, 1])
res = p.roots()
tgt = [0, .5, 1]
assert_almost_equal(res, tgt)
def test_linspace(self):
xdes = np.linspace(0, 1, 20)
ydes = self.p2(xdes)
xres, yres = self.p2.linspace(20)
assert_almost_equal(xres, xdes)
assert_almost_equal(yres, ydes)
def test_fromroots(self):
roots = [0, .5, 1]
p = herm.Hermite.fromroots(roots, domain=[0, 1])
res = p.coef
tgt = herm.poly2herm([0, -1, 0, 1])
assert_almost_equal(res, tgt)
def test_fit(self):
def f(x):
return x * (x - 1) * (x - 2)
x = np.linspace(0, 3)
y = f(x)
# test default value of domain
p = herm.Hermite.fit(x, y, 3)
assert_almost_equal(p.domain, [0, 3])
# test that fit works in given domains
p = herm.Hermite.fit(x, y, 3, None)
assert_almost_equal(p(x), y)
assert_almost_equal(p.domain, [0, 3])
p = herm.Hermite.fit(x, y, 3, [])
assert_almost_equal(p(x), y)
assert_almost_equal(p.domain, [-1, 1])
# test that fit accepts weights.
w = np.zeros_like(x)
yw = y.copy()
w[1::2] = 1
yw[0::2] = 0
p = herm.Hermite.fit(x, yw, 3, w=w)
assert_almost_equal(p(x), y)
def test_identity(self):
x = np.linspace(0, 3)
p = herm.Hermite.identity()
assert_almost_equal(p(x), x)
p = herm.Hermite.identity([1, 3])
assert_almost_equal(p(x), x)
