Chebpy is a Python implementation of Chebfun.

For convenience we'll import everything from numpy and matplotlib.

from numpy import *
from matplotlib.pyplot import *
from chebpy import chebfun

The function chebfun behaves in much the same way as its Matlab counterpart. As good a way as any to begin is to type:

x = chebfun('x', [0, 10])
x

What's happened here is that we've instantiated a numerical representation of the identity function on the interval [0,10] and assigned this to a computer variable called x. This representation has length 2, meaning that it consists of two degrees of freedom (as you would expect of a linear function).

Arbitrary functions of the variable x can now be defined. For instance, here is a function f that oscillates with two modal frequencies.

f = sin(x) + sin(5*x)
f

The zeros of f can be computed via the command roots:

r = f.roots();
r

One can in general expect Chebpy computations to be accurate to machine precision, which is to say to approximately fifteen digits in double-precision floating-point arithmetic. We can verify this for the computed roots of f by computing:

f(r)

The function and its roots can be plotted together as follows:

f.plot();
plot(r, f(r), 'or');
title('An oscillatory function and its roots');

Calculus operations are possible with Chebfun objects. Here for instance is the derivative and indefinite integral of f:

Df = f.diff()
If = f.cumsum()
f.plot(); Df.plot(); If.plot()
legend(['f', 'df/dx', 'integral']);

One can verify by elementary calculus that the exact value of the definite integral of f is equal to:

1.2-cos(10)-.2*cos(50)

This matches the numerical integral, computed via the sum command, to the stated level of precision:

f.sum()

Chebfun is capable of handling point-discontinuities. Here's one way of seeing this in which we compute the pointwise maximum of two functions. The resulting function is 'piecewise-smooth', being defined as the concatenation of twelve individual smooth pieces. The breakpoints have been automatically determined by solving the corresponding root-finding problem.

g = x/5 - 1
h = f.maximum(g)
h

Here's a plot of the two functions f and g, and their pointwise maximum, h:

f.plot(linewidth=1, linestyle='--')
g.plot(linewidth=1, linestyle='--')
h.plot()
ylim([-2.5, 2.5]);

The piecewise function h is just another Chebfun representation, and the same set of operations can be applied as before. Here for instance is the exponential of h and its integral:

exp(h).plot();

exp(h).sum()

Here's a further example, this time related to statistics. We consider the following Chebfun representation of the standardised Gaussian distribution. We use a sufficiently wide interval as to facilitate a machine-precision representation. On this occasion we utlilise a slightly different (but still perfectly valid) approach to construction whereby we supply the function handle -- in this case, a Python lambda, but more generally any object in possession of a __call__ attribute --together with the interval of definition.

gaussian = lambda x: 1/sqrt(2*pi) * exp(-.5*x**2)
pdf = chebfun(gaussian, [-15, 15])
pdf.plot()
ylim([-0.05,.45]);
title('Standard Gaussian distribution (mean  0, variance 1)');

The integral of any probability density function should be 1, and this is the case for our numerical approximation:

pdf.sum()

Suppose we wish to generate quantiles of the distribution. This can be achieved as follows. First we form the cumulative distribution function, computed as the indefinite integral (cumsum) of the density:

cdf = pdf.cumsum()
cdf.plot()
ylim([-.1,1.1]);

Then it is simply a case of utilising the roots command to determine the standardised score (sometimes known as "z-score") corresponding to the quantile of interest. For example:

print 'quantile    z-score '
print '--------------------'
for quantile in arange(.1, .0, -.01):
    print '  {:2.0f}%       {:+5.3f}'.format(1e2*quantile, (cdf-quantile).roots()[0])

Other distributional properties are also computable. Here's how we can compute the first four normalised and centralised moments (Mean, Variance, Skew, Kurtosis):

x = pdf.x
m1 = (pdf*x).sum()
m2 = (pdf*(x-m1)*(x-m1)).sum()
m3 = (pdf*(x-m1)*(x-m1)*(x-m1)).sum() / m2**1.5
m4 = (pdf*(x-m1)*(x-m1)*(x-m1)*(x-m1)).sum() / m2**2
print '    mean = {:+.4f}'.format(m1)
print 'variance = {:+.4f}'.format(m2)
print '    skew = {:+.4f}'.format(m3)
print 'kurtosis = {:+.4f}'.format(m4)

variance = +1.0000

skew = -0.0000

kurtosis = +3.0000

• For installation details, see INSTALL.rst.
• For implementation notes, see implementation-notes.rst