242 lines
7.0 KiB
Python
242 lines
7.0 KiB
Python
from __future__ import division, absolute_import, print_function
|
|
|
|
'''
|
|
>>> p = np.poly1d([1.,2,3])
|
|
>>> p
|
|
poly1d([ 1., 2., 3.])
|
|
>>> print(p)
|
|
2
|
|
1 x + 2 x + 3
|
|
>>> q = np.poly1d([3.,2,1])
|
|
>>> q
|
|
poly1d([ 3., 2., 1.])
|
|
>>> print(q)
|
|
2
|
|
3 x + 2 x + 1
|
|
>>> print(np.poly1d([1.89999+2j, -3j, -5.12345678, 2+1j]))
|
|
3 2
|
|
(1.9 + 2j) x - 3j x - 5.123 x + (2 + 1j)
|
|
>>> print(np.poly1d([-3, -2, -1]))
|
|
2
|
|
-3 x - 2 x - 1
|
|
|
|
>>> p(0)
|
|
3.0
|
|
>>> p(5)
|
|
38.0
|
|
>>> q(0)
|
|
1.0
|
|
>>> q(5)
|
|
86.0
|
|
|
|
>>> p * q
|
|
poly1d([ 3., 8., 14., 8., 3.])
|
|
>>> p / q
|
|
(poly1d([ 0.33333333]), poly1d([ 1.33333333, 2.66666667]))
|
|
>>> p + q
|
|
poly1d([ 4., 4., 4.])
|
|
>>> p - q
|
|
poly1d([-2., 0., 2.])
|
|
>>> p ** 4
|
|
poly1d([ 1., 8., 36., 104., 214., 312., 324., 216., 81.])
|
|
|
|
>>> p(q)
|
|
poly1d([ 9., 12., 16., 8., 6.])
|
|
>>> q(p)
|
|
poly1d([ 3., 12., 32., 40., 34.])
|
|
|
|
>>> np.asarray(p)
|
|
array([ 1., 2., 3.])
|
|
>>> len(p)
|
|
2
|
|
|
|
>>> p[0], p[1], p[2], p[3]
|
|
(3.0, 2.0, 1.0, 0)
|
|
|
|
>>> p.integ()
|
|
poly1d([ 0.33333333, 1. , 3. , 0. ])
|
|
>>> p.integ(1)
|
|
poly1d([ 0.33333333, 1. , 3. , 0. ])
|
|
>>> p.integ(5)
|
|
poly1d([ 0.00039683, 0.00277778, 0.025 , 0. , 0. ,
|
|
0. , 0. , 0. ])
|
|
>>> p.deriv()
|
|
poly1d([ 2., 2.])
|
|
>>> p.deriv(2)
|
|
poly1d([ 2.])
|
|
|
|
>>> q = np.poly1d([1.,2,3], variable='y')
|
|
>>> print(q)
|
|
2
|
|
1 y + 2 y + 3
|
|
>>> q = np.poly1d([1.,2,3], variable='lambda')
|
|
>>> print(q)
|
|
2
|
|
1 lambda + 2 lambda + 3
|
|
|
|
>>> np.polydiv(np.poly1d([1,0,-1]), np.poly1d([1,1]))
|
|
(poly1d([ 1., -1.]), poly1d([ 0.]))
|
|
|
|
'''
|
|
import numpy as np
|
|
from numpy.testing import (
|
|
run_module_suite, assert_, assert_equal, assert_array_equal,
|
|
assert_almost_equal, assert_array_almost_equal, assert_raises, rundocs
|
|
)
|
|
|
|
|
|
class TestDocs(object):
|
|
def test_doctests(self):
|
|
return rundocs()
|
|
|
|
def test_poly(self):
|
|
assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]),
|
|
[1, -3, -2, 6])
|
|
|
|
# From matlab docs
|
|
A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]
|
|
assert_array_almost_equal(np.poly(A), [1, -6, -72, -27])
|
|
|
|
# Should produce real output for perfect conjugates
|
|
assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j])))
|
|
assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j,
|
|
1-2j, 1.+3.5j, 1-3.5j])))
|
|
assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j])))
|
|
assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j])))
|
|
assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j])))
|
|
assert_(np.isrealobj(np.poly([1j, -1j])))
|
|
assert_(np.isrealobj(np.poly([1, -1])))
|
|
|
|
assert_(np.iscomplexobj(np.poly([1j, -1.0000001j])))
|
|
|
|
np.random.seed(42)
|
|
a = np.random.randn(100) + 1j*np.random.randn(100)
|
|
assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
|
|
|
|
def test_roots(self):
|
|
assert_array_equal(np.roots([1, 0, 0]), [0, 0])
|
|
|
|
def test_str_leading_zeros(self):
|
|
p = np.poly1d([4, 3, 2, 1])
|
|
p[3] = 0
|
|
assert_equal(str(p),
|
|
" 2\n"
|
|
"3 x + 2 x + 1")
|
|
|
|
p = np.poly1d([1, 2])
|
|
p[0] = 0
|
|
p[1] = 0
|
|
assert_equal(str(p), " \n0")
|
|
|
|
def test_polyfit(self):
|
|
c = np.array([3., 2., 1.])
|
|
x = np.linspace(0, 2, 7)
|
|
y = np.polyval(c, x)
|
|
err = [1, -1, 1, -1, 1, -1, 1]
|
|
weights = np.arange(8, 1, -1)**2/7.0
|
|
|
|
# Check exception when too few points for variance estimate. Note that
|
|
# the Bayesian estimate requires the number of data points to exceed
|
|
# degree + 3.
|
|
assert_raises(ValueError, np.polyfit,
|
|
[0, 1, 3], [0, 1, 3], deg=0, cov=True)
|
|
|
|
# check 1D case
|
|
m, cov = np.polyfit(x, y+err, 2, cov=True)
|
|
est = [3.8571, 0.2857, 1.619]
|
|
assert_almost_equal(est, m, decimal=4)
|
|
val0 = [[2.9388, -5.8776, 1.6327],
|
|
[-5.8776, 12.7347, -4.2449],
|
|
[1.6327, -4.2449, 2.3220]]
|
|
assert_almost_equal(val0, cov, decimal=4)
|
|
|
|
m2, cov2 = np.polyfit(x, y+err, 2, w=weights, cov=True)
|
|
assert_almost_equal([4.8927, -1.0177, 1.7768], m2, decimal=4)
|
|
val = [[8.7929, -10.0103, 0.9756],
|
|
[-10.0103, 13.6134, -1.8178],
|
|
[0.9756, -1.8178, 0.6674]]
|
|
assert_almost_equal(val, cov2, decimal=4)
|
|
|
|
# check 2D (n,1) case
|
|
y = y[:, np.newaxis]
|
|
c = c[:, np.newaxis]
|
|
assert_almost_equal(c, np.polyfit(x, y, 2))
|
|
# check 2D (n,2) case
|
|
yy = np.concatenate((y, y), axis=1)
|
|
cc = np.concatenate((c, c), axis=1)
|
|
assert_almost_equal(cc, np.polyfit(x, yy, 2))
|
|
|
|
m, cov = np.polyfit(x, yy + np.array(err)[:, np.newaxis], 2, cov=True)
|
|
assert_almost_equal(est, m[:, 0], decimal=4)
|
|
assert_almost_equal(est, m[:, 1], decimal=4)
|
|
assert_almost_equal(val0, cov[:, :, 0], decimal=4)
|
|
assert_almost_equal(val0, cov[:, :, 1], decimal=4)
|
|
|
|
def test_objects(self):
|
|
from decimal import Decimal
|
|
p = np.poly1d([Decimal('4.0'), Decimal('3.0'), Decimal('2.0')])
|
|
p2 = p * Decimal('1.333333333333333')
|
|
assert_(p2[1] == Decimal("3.9999999999999990"))
|
|
p2 = p.deriv()
|
|
assert_(p2[1] == Decimal('8.0'))
|
|
p2 = p.integ()
|
|
assert_(p2[3] == Decimal("1.333333333333333333333333333"))
|
|
assert_(p2[2] == Decimal('1.5'))
|
|
assert_(np.issubdtype(p2.coeffs.dtype, np.object_))
|
|
p = np.poly([Decimal(1), Decimal(2)])
|
|
assert_equal(np.poly([Decimal(1), Decimal(2)]),
|
|
[1, Decimal(-3), Decimal(2)])
|
|
|
|
def test_complex(self):
|
|
p = np.poly1d([3j, 2j, 1j])
|
|
p2 = p.integ()
|
|
assert_((p2.coeffs == [1j, 1j, 1j, 0]).all())
|
|
p2 = p.deriv()
|
|
assert_((p2.coeffs == [6j, 2j]).all())
|
|
|
|
def test_integ_coeffs(self):
|
|
p = np.poly1d([3, 2, 1])
|
|
p2 = p.integ(3, k=[9, 7, 6])
|
|
assert_(
|
|
(p2.coeffs == [1/4./5., 1/3./4., 1/2./3., 9/1./2., 7, 6]).all())
|
|
|
|
def test_zero_dims(self):
|
|
try:
|
|
np.poly(np.zeros((0, 0)))
|
|
except ValueError:
|
|
pass
|
|
|
|
def test_poly_int_overflow(self):
|
|
"""
|
|
Regression test for gh-5096.
|
|
"""
|
|
v = np.arange(1, 21)
|
|
assert_almost_equal(np.poly(v), np.poly(np.diag(v)))
|
|
|
|
def test_poly_eq(self):
|
|
p = np.poly1d([1, 2, 3])
|
|
p2 = np.poly1d([1, 2, 4])
|
|
assert_equal(p == None, False)
|
|
assert_equal(p != None, True)
|
|
assert_equal(p == p, True)
|
|
assert_equal(p == p2, False)
|
|
assert_equal(p != p2, True)
|
|
|
|
def test_poly_coeffs_immutable(self):
|
|
""" Coefficients should not be modifiable """
|
|
p = np.poly1d([1, 2, 3])
|
|
|
|
try:
|
|
# despite throwing an exception, this used to change state
|
|
p.coeffs += 1
|
|
except Exception:
|
|
pass
|
|
assert_equal(p.coeffs, [1, 2, 3])
|
|
|
|
p.coeffs[2] += 10
|
|
assert_equal(p.coeffs, [1, 2, 3])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
run_module_suite()
|