def test_diff_one(self):
"""
Derivative of Chebfun(1) close to zero
"""
one = Chebfun(1.)
zero = one.differentiate()
npt.assert_allclose(tools.Zero(tools.xs), 0.)
def test_prune(self):
N = 10
coeffs = np.array([1.]+N*[0])
c0 = Chebfun.from_coeff(coeffs)
npt.assert_allclose(c0.coefficients(), [1.])
c1 = Chebfun.from_coeff(coeffs, prune=False)
npt.assert_allclose(c1.coefficients(), coeffs)
def test_interp_values(self):
"""
Instanciate Chebfun from interpolation values.
"""
p2 = Chebfun(self.p.values())
npt.assert_almost_equal(self.p.coefficients(), p2.coefficients())
tools.assert_close(self.p, p2)
def test_add(self):
s = Chebfun.from_function(np.sin)
c = Chebfun.from_function(np.cos)
r = c + s
def expected(x):
return np.sin(x) + np.cos(x)
tools.assert_close(r, expected)
def test_truncate(self, N=17):
"""
Check that the Chebyshev coefficients are properly truncated.
"""
small = Chebfun.from_function(tools.f, N=N)
new = Chebfun.from_function(small)
self.assertEqual(new.size(), small.size(),)
def test_real_imag(self):
datar = np.random.rand(10)
datai = np.random.rand(10)
cc = Chebfun.from_data(datar + 1j*datai)
cr = Chebfun.from_data(datar)
ci = Chebfun.from_data(datai)
tools.assert_close(np.real(cc), cr)
tools.assert_close(np.imag(cc), ci)
def test_runge(self):
"""
Test some of the capabilities of operator overloading.
"""
r = Chebfun.from_function(runge)
x = Chebfun.basis(1)
rr = 1./(1+25*x**2)
tools.assert_close(r, rr, rtol=1e-13)
def test_scalarvectormult(self):
"""
Possible to multiply scalar with vector chebfun.
"""
v = Chebfun.from_function(segment)
s = np.sin(Chebfun.identity())
m = s * v
tools.assert_close(m[0], s*v[0])
def test_slice(self):
"""
Test slicing: f[0] should return the first component.
"""
s = Chebfun.from_function(segment)
tools.assert_close(s[0], Chebfun.identity())
tools.assert_close(s[1], Chebfun(0.))
tools.assert_close(s[:], s)
def a(p, order):
if p > 0:
return Chebfun.from_function(lambda x: sqrt(2)* np.sin(p*x)/p,[0,pi])\
.differentiate(order)
else:
if order == 1:
return Chebfun.from_function(lambda x: np.ones_like(x), [0, pi])
else:
return Chebfun.from_function(lambda x: np.zeros_like(x), [0, pi])
def test_roots_of_flat_function(self):
"""
Check roots() does not fail for extremely flat Chebfuns such
as those representing cumulative distribution functions.
"""
cdf = Chebfun.from_data(flat_chebfun_vals, domain=[-0.7, 0.7])
npt.assert_allclose((cdf - 0.05).roots(), 0.1751682246791747)
def test_basis(self, n=4):
"""
Tn(cos(t)) = cos(nt)
"""
Tn = Chebfun.basis(n)
ts = np.linspace(0, 2*np.pi, 100)
npt.assert_allclose(Tn(np.cos(ts)), np.cos(n*ts))
def test_sum(self):
"""
Integral of chebfun of x**2 on [-1,1] is 2/3
"""
p = Chebfun.from_function(Quad)
i = p.sum()
npt.assert_array_almost_equal(i,2/3)
def test_highdiff(self):
"""
Higher order derivatives of exp(x)
"""
e = Chebfun.from_function(lambda x:np.exp(x))
e4 = e.differentiate(4)
tools.assert_close(e4, e)
def test_diffquad(self):
"""
Derivative of Chebfun(x**2/2) is close to identity function
"""
self.p = .5*Chebfun.from_function(Quad)
X = self.p.differentiate()
tools.assert_close(X, lambda x:x)
def test_nonzero(self):
"""
nonzero is True for Chebfun(f) and False for Chebfun(0)
"""
self.assertTrue(self.p)
mp = Chebfun.from_function(tools.Zero)
self.assertFalse(mp)
def test_chebyshev_points(self):
"""
First and last interpolation points are -1 and 1
"""
N = pow(2,5)
pts = Chebfun.interpolation_points(N)
npt.assert_array_almost_equal(pts[[0,-1]],np.array([1.,-1]))
def test_init(ufunc):
xx = Chebfun.from_function(lambda x: x, [0.25, 0.75])
ff = ufunc(xx)
assert isinstance(ff, Chebfun)
result = ff.values()
expected = ufunc(ff._ui_to_ab(ff.p.xi))
npt.assert_allclose(result, expected)
def test_zero(self):
"""
Chebfun for zero has the minimal degree 5
"""
p = Chebfun.from_function(tools.Zero)
self.assertEqual(p.size(),
1) # should be equal to the minimum length, 1
def test_highdiff(self):
"""
Higher order derivatives of exp(x)
"""
e = Chebfun.from_function(lambda x: np.exp(x))
e4 = e.differentiate(4)
tools.assert_close(e4, e)
def test_sum(self):
"""
Integral of chebfun of x**2 on [-1,1] is 2/3
"""
p = Chebfun.from_function(Quad)
i = p.sum()
npt.assert_array_almost_equal(i, 2 / 3)
def test_basis(self, n=4):
"""
Tn(cos(t)) = cos(nt)
"""
Tn = Chebfun.basis(n)
ts = np.linspace(0, 2 * np.pi, 100)
npt.assert_allclose(Tn(np.cos(ts)), np.cos(n * ts))
def test_square(self):
def square(x):
return self.p(x) * self.p(x)
sq = Chebfun.from_function(square)
npt.assert_array_less(0, sq(tools.xs))
self.sq = sq
def __init__(self, inputdistribution, precision, minexp, maxexp,
poly_precision):
'''
Constructor interpolates the density function using Chebyshev interpolation
then uses this interpolation to build a PaCal object:
the self.distribution attribute which contains all the methods we could possibly want
Inputs:
inputdistribution: a PaCal object representing the distribution for which we want to compute
the rounding error distribution
precision, minexp, maxexp: specify the low precision environment suing gmpy2
poly_precision: the number of exact evaluations of the density function used to
build the interpolating polynomial representing it
'''
self.inputdistribution = inputdistribution
self.precision = precision
self.minexp = minexp
self.maxexp = maxexp
self.poly_precision = poly_precision
# Test if the range of floating point number covers enough of the inputdistribution
x = gmpy2.next_above(gmpy2.inf(-1))
y = gmpy2.next_below(gmpy2.inf(1))
coverage = self.inputdistribution.get_piecewise_pdf().integrate(
float(x), float(y))
if (1.0 - coverage) > 0.001:
raise Exception(
'The range of floating points is too narrow, increase maxexp and increase minexp'
)
# Builds the Chebyshev polynomial rerpesentation of the density function
self.pdf = Chebfun.from_function(lambda t: self.__getpdf(t),
N=self.poly_precision)
# Creates a PaCal object containing the distribution
self.distribution = FunDistr(self.pdf, [-1, 1])
def test_chebyshev_points(self):
"""
First and last interpolation points are -1 and 1
"""
N = pow(2, 5)
pts = Chebfun.interpolation_points(N)
npt.assert_array_almost_equal(pts[[0, -1]], np.array([1., -1]))
def test_roots_of_flat_function(self):
"""
Check roots() does not fail for extremely flat Chebfuns such
as those representing cumulative distribution functions.
"""
cdf = Chebfun.from_data(flat_chebfun_vals, domain=[-0.7, 0.7])
npt.assert_allclose((cdf-0.05).roots(), 0.1751682246791747)
def test_nonzero(self):
"""
nonzero is True for Chebfun(f) and False for Chebfun(0)
"""
self.assertTrue(self.p)
mp = Chebfun.from_function(tools.Zero)
self.assertFalse(mp)
def test_init(ufunc):
xx = Chebfun.from_function(lambda x: x,[0.25,0.75])
ff = ufunc(xx)
assert isinstance(ff, Chebfun)
result = ff.values()
expected = ufunc(ff._ui_to_ab(ff.p.xi))
npt.assert_allclose(result, expected)
def test_diffquad(self):
"""
Derivative of Chebfun(x**2/2) is close to identity function
"""
self.p = .5 * Chebfun.from_function(Quad)
X = self.p.differentiate()
tools.assert_close(X, lambda x: x)
def test_integrate(self):
"""
Integrate exp
"""
e = Chebfun.from_function(lambda x: np.exp(x))
antideriv = e.integrate()
result = antideriv - antideriv(antideriv._domain[0])
tools.assert_close(result, e - e(antideriv._domain[0]))
def test_integrate(self):
"""
Integrate exp
"""
e = Chebfun.from_function(lambda x:np.exp(x))
antideriv = e.integrate()
result = antideriv - antideriv(antideriv._domain[0])
tools.assert_close(result, e - e(antideriv._domain[0]))
def test_diff_x(self):
"""
First and second derivative of Chebfun(x) are close to one and zero respectively.
"""
self.p = Chebfun.from_function(tools.Identity)
one = self.p.differentiate()
zero = one.differentiate()
npt.assert_allclose(one(tools.xs), 1.)
npt.assert_allclose(tools.Zero(tools.xs), 0.)
def test_diff_x(self):
"""
First and second derivative of Chebfun(x) are close to one and zero respectively.
"""
self.p = Chebfun.from_function(tools.Identity)
one = self.p.differentiate()
zero = one.differentiate()
npt.assert_allclose(one(tools.xs), 1.)
npt.assert_allclose(tools.Zero(tools.xs), 0.)
def test_repr(self):
"""
Repr shows the interpolation values.
"""
self.skipTest('Representation changed to include domain information')
p = Chebfun.basis(1)
s = repr(p)
expected = '<Chebfun(array([ 1., -1.]))>'
self.assertEqual(s, expected)
def test_repr(self):
"""
Repr shows the interpolation values.
"""
self.skipTest('Representation changed to include domain information')
p = Chebfun.basis(1)
s = repr(p)
expected = '<Chebfun(array([ 1., -1.]))>'
self.assertEqual(s, expected)
def test_N(self):
"""
Check initialisation with a fixed N
"""
N = self.p.size() - 1
pN = Chebfun.from_function(tools.f, N=N)
self.assertEqual(len(pN.coefficients()), N + 1)
self.assertEqual(len(pN.coefficients()), pN.size())
tools.assert_close(pN, self.p)
npt.assert_allclose(pN.coefficients(), self.p.coefficients())
def test_dot(self):
"""
f.0 = 0
f.1 = f.sum()
"""
p = Chebfun.from_function(np.sin)
z = p.dot(Chebfun(0.))
self.assertAlmostEqual(z, 0.)
s = p.dot(Chebfun(1.))
self.assertAlmostEqual(s, p.sum())
def test_add_mistype(self):
"""
Possible to add a Chebfun and a function
"""
self.skipTest('not possible to add function and chebfun yet')
def f(x):
return np.sin(x)
c = Chebfun.from_function(f)
result = c + f
self.assertIsInstance(result, Chebfun)
def test_N(self):
"""
Check initialisation with a fixed N
"""
N = self.p.size() - 1
pN = Chebfun.from_function(tools.f, N=N)
self.assertEqual(len(pN.coefficients()), N+1)
self.assertEqual(len(pN.coefficients()),pN.size())
tools.assert_close(pN, self.p)
npt.assert_allclose(pN.coefficients(),self.p.coefficients())
def tdata(request):
index = request.param
class TData(): pass
tdata = TData()
tdata.function = data.IntervalTestData.functions[0]
tdata.function_d = data.IntervalTestData.first_derivs[0]
tdata.domain = data.IntervalTestData.domains[index]
tdata.roots = data.IntervalTestData.roots[0][index]
tdata.integral = data.IntervalTestData.integrals[0][index]
tdata.chebfun = Chebfun.from_function(tdata.function, tdata.domain)
return tdata
def test_add_mistype(self):
"""
Possible to add a Chebfun and a function
"""
self.skipTest('not possible to add function and chebfun yet')
def f(x):
return np.sin(x)
c = Chebfun.from_function(f)
result = c + f
self.assertIsInstance(result, Chebfun)
def test_ufunc(ufunc):
"""
Check that ufuncs work and give the right result.
arccosh is not tested
"""
# transformation from [-1, 1] to [1/4, 3/4]
trans = lambda x: (x+2)/4
x2 = Chebfun.from_function(trans)
cf = ufunc(x2)
assert isinstance(cf, Chebfun)
result = cf.values()
expected = ufunc(trans(cf.p.xi))
npt.assert_allclose(result, expected)
def test_ufunc(ufunc):
"""
Check that ufuncs work and give the right result.
arccosh is not tested
"""
# transformation from [-1, 1] to [1/4, 3/4]
trans = lambda x: (x + 2) / 4
x2 = Chebfun.from_function(trans)
cf = ufunc(x2)
assert isinstance(cf, Chebfun)
result = cf.values()
expected = ufunc(trans(cf.p.xi))
npt.assert_allclose(result, expected)
def tdata(request):
index = request.param
class TData():
pass
tdata = TData()
tdata.function = data.IntervalTestData.functions[0]
tdata.function_d = data.IntervalTestData.first_derivs[0]
tdata.domain = data.IntervalTestData.domains[index]
tdata.roots = data.IntervalTestData.roots[0][index]
tdata.integral = data.IntervalTestData.integrals[0][index]
tdata.chebfun = Chebfun.from_function(tdata.function, tdata.domain)
return tdata
def test_from_chebfun(self):
ce = Chebfun.from_function(tools.f)
cr = chebfun(ce)
tools.assert_close(cr, ce)
def test_from_chebcoeffs(self):
coeffs = np.random.randn(10)
cr = chebfun(chebcoeff=coeffs)
ce = Chebfun.from_coeff(coeffs)
tools.assert_close(cr, ce)
def setUp(self):
# Construct the O(dx^-16) "spectrally accurate" chebfun p
self.p = Chebfun.from_function(tools.f)
def test_scalar_mul(self):
self.assertEqual(self.p1, self.p1)
self.assertEqual(self.p1 * 1, 1 * self.p1)
self.assertEqual(self.p1 * 1, self.p1)
self.assertEqual(0 * self.p1, Chebfun.from_function(tools.Zero))
def setUp(self):
self.p1 = Chebfun.from_function(tools.f)
self.p2 = Chebfun.from_function(runge)
def test_underflow(self):
self.skipTest('mysterious underflow error')
p = Chebfun.from_function(piecewise_continuous, N=pow(2, 10) - 1)
def test_chebpolyfit(self):
N = 32
data = np.random.rand(N - 1, 2)
coeffs = Chebfun.polyfit(data)
result = Chebfun.polyval(coeffs)
npt.assert_allclose(data, result)
def test_chebpolyfitval(self, N=64):
data = np.random.rand(N - 1, 2)
computed = Chebfun.polyval(Chebfun.polyfit(data))
npt.assert_allclose(computed, data)
def test_no_convergence(self):
with self.assertRaises(Chebfun.NoConvergence):
Chebfun.from_function(np.sign)
def test_list_init(self):
c = Chebfun([1.])
npt.assert_array_almost_equal(c.coefficients(), np.array([1.]))
def test_basis(self, ns=[0, 5]):
for n in ns:
c = Chebfun.basis(n)
npt.assert_array_almost_equal(c.coefficients(),
np.array([0] * n + [1.]))
def test_from_values(self):
values = np.random.randn(10)
cr = chebfun(values)
ce = Chebfun.from_data(values)
tools.assert_close(cr, ce)
def test_mismatch(self):
c1 = Chebfun.identity()
c2 = Chebfun.from_function(lambda x:x, domain=[2,3])
for op in [operator.add, operator.sub, operator.mul, operator.truediv]:
with self.assertRaises(Chebfun.DomainMismatch):
op(c1, c2)
def test_restrict(self):
x = Chebfun.identity()
with self.assertRaises(ValueError):
x.restrict([-2,0])
with self.assertRaises(ValueError):
x.restrict([0,2])
def test_from_scalar(self):
val = np.random.rand()
cr = chebfun(val)
ce = Chebfun.from_data([val])
tools.assert_close(cr, ce)
def test_init(ufunc):
xx = Chebfun.from_function(lambda x: x,[0.25,0.75])
ff = ufunc(xx)
assert isinstance(ff, Chebfun)
result = ff.values()
expected = ufunc(ff._ui_to_ab(ff.p.xi))
npt.assert_allclose(result, expected)
#------------------------------------------------------------------------------
# Test the restrict operator
#------------------------------------------------------------------------------
from . import data
@pytest.mark.parametrize('ff', [Chebfun.from_function(tools.f,[-3,4])])
@pytest.mark.parametrize('domain', data.IntervalTestData.domains)
def test_restrict(ff, domain):
ff_ = ff.restrict(domain)
xx = tools.map_ui_ab(tools.xs, domain[0],domain[1])
tools.assert_close(tools.f, ff_, xx)
#------------------------------------------------------------------------------
# Add the arbitrary interval tests
#------------------------------------------------------------------------------
@pytest.fixture(params=list(range(5)))
def tdata(request):
index = request.param
class TData(): pass
tdata = TData()
