# Chebyshev approximation in Python

Chebyshev approximation is covered in Chapter 5.8 of Numerical Recipes in C.

Here's a similar implementation in Python:

```import math

class Chebyshev:
"""
Chebyshev(a, b, n, func)
Given a function func, lower and upper limits of the interval [a,b],
and maximum degree n, this class computes a Chebyshev approximation
of the function.
Method eval(x) yields the approximated function value.
"""
def __init__(self, a, b, n, func):
self.a = a
self.b = b
self.func = func

bma = 0.5 * (b - a)
bpa = 0.5 * (b + a)
f = [func(math.cos(math.pi * (k + 0.5) / n) * bma + bpa) for k in range(n)]
fac = 2.0 / n
self.c = [fac * sum([f[k] * math.cos(math.pi * j * (k + 0.5) / n)
for k in range(n)]) for j in range(n)]

def eval(self, x):
a,b = self.a, self.b
assert(a <= x <= b)
y = (2.0 * x - a - b) * (1.0 / (b - a))
y2 = 2.0 * y
(d, dd) = (self.c[-1], 0)             # Special case first step for efficiency
for cj in self.c[-2:0:-1]:            # Clenshaw's recurrence
(d, dd) = (y2 * d - dd + cj, d)
return y * d - dd + 0.5 * self.c[0]   # Last step is different
```

For example, to make an 8th-degree approximation to sinx, where 0 ≤ x ≤ (π)/(12), and use it to compute sin0.1:

```>>> import math
>>> from chebyshev import Chebyshev
>>> ch = Chebyshev(0, math.pi / 12, 8, math.sin)
>>> ch.eval(0.1)
0.099833416646828876
>>> math.sin(0.1)
0.099833416646828155
```