def test_interpolating_poly():
x0, x1, x2, y0, y1, y2 = symbols("x:3, y:3")
assert interpolating_poly(0, x) == 0
assert interpolating_poly(1, x) == y0
assert interpolating_poly(2, x) == y0 * (x - x1) / (x0 - x1) + y1 * (x - x0) / (x1 - x0)
assert interpolating_poly(3, x) == y0 * (x - x1) * (x - x2) / ((x0 - x1) * (x0 - x2)) + y1 * (x - x0) * (x - x2) / (
(x1 - x0) * (x1 - x2)
) + y2 * (x - x0) * (x - x1) / ((x2 - x0) * (x2 - x1))
def interpolate(data, x):
"""
Construct an interpolating polynomial for the data points.
Examples
========
>>> from sympy.polys.polyfuncs import interpolate
>>> from sympy.abc import x
A list is interpreted as though it were paired with a range starting
from 1:
>>> interpolate([1, 4, 9, 16], x)
x**2
This can be made explicit by giving a list of coordinates:
>>> interpolate([(1, 1), (2, 4), (3, 9)], x)
x**2
The (x, y) coordinates can also be given as keys and values of a
dictionary (and the points need not be equispaced):
>>> interpolate([(-1, 2), (1, 2), (2, 5)], x)
x**2 + 1
>>> interpolate({-1: 2, 1: 2, 2: 5}, x)
x**2 + 1
"""
n = len(data)
poly = None
if isinstance(data, dict):
X, Y = list(zip(*data.items()))
poly = interpolating_poly(n, x, X, Y)
else:
if isinstance(data[0], tuple):
X, Y = list(zip(*data))
poly = interpolating_poly(n, x, X, Y)
else:
Y = list(data)
numert = Mul(*[(x - i) for i in range(1, n + 1)])
denom = -factorial(n - 1) if n % 2 == 0 else factorial(n - 1)
coeffs = []
for i in range(1, n + 1):
coeffs.append(numert / (x - i) / denom)
denom = denom / (i - n) * i
poly = Add(*[coeff * y for coeff, y in zip(coeffs, Y)])
return poly.expand()
def interpolate(data, x):
"""
Construct an interpolating polynomial for the data points.
Examples
========
>>> from sympy.polys.polyfuncs import interpolate
>>> from sympy.abc import x
A list is interpreted as though it were paired with a range starting
from 1:
>>> interpolate([1, 4, 9, 16], x)
x**2
This can be made explicit by giving a list of coordinates:
>>> interpolate([(1, 1), (2, 4), (3, 9)], x)
x**2
The (x, y) coordinates can also be given as keys and values of a
dictionary (and the points need not be equispaced):
>>> interpolate([(-1, 2), (1, 2), (2, 5)], x)
x**2 + 1
>>> interpolate({-1: 2, 1: 2, 2: 5}, x)
x**2 + 1
"""
n = len(data)
poly = None
if isinstance(data, dict):
X, Y = list(zip(*data.items()))
poly = interpolating_poly(n, x, X, Y)
else:
if isinstance(data[0], tuple):
X, Y = list(zip(*data))
poly = interpolating_poly(n, x, X, Y)
else:
Y = list(data)
numert = Mul(*[(x - i) for i in range(1, n + 1)])
denom = -factorial(n - 1) if n%2 == 0 else factorial(n - 1)
coeffs = []
for i in range(1, n + 1):
coeffs.append(numert/(x - i)/denom)
denom = denom/(i - n)*i
poly = Add(*[coeff*y for coeff, y in zip(coeffs, Y)])
return poly.expand()
def test_interpolating_poly():
x0, x1, x2, y0, y1, y2 = symbols('x:3, y:3')
assert interpolating_poly(0, x) == 0
assert interpolating_poly(1, x) == y0
assert interpolating_poly(2, x) == \
y0*(x - x1)/(x0 - x1) + y1*(x - x0)/(x1 - x0)
assert interpolating_poly(3, x) == \
y0*(x - x1)*(x - x2)/((x0 - x1)*(x0 - x2)) + \
y1*(x - x0)*(x - x2)/((x1 - x0)*(x1 - x2)) + \
y2*(x - x0)*(x - x1)/((x2 - x0)*(x2 - x1))
def interpolate(data, x):
"""
Construct an interpolating polynomial for the data points.
**Examples**
>>> from sympy.polys.polyfuncs import interpolate
>>> from sympy.abc import x
>>> interpolate([1, 4, 9, 16], x)
x**2
>>> interpolate([(1, 1), (2, 4), (3, 9)], x)
x**2
>>> interpolate([(1, 2), (2, 5), (3, 10)], x)
1 + x**2
>>> interpolate({1: 2, 2: 5, 3: 10}, x)
1 + x**2
"""
n = len(data)
if isinstance(data, dict):
X, Y = zip(*data.items())
else:
if isinstance(data[0], tuple):
X, Y = zip(*data)
else:
X = range(1, n+1)
Y = list(data)
poly = interpolating_poly(n, x, X, Y)
return poly.expand()
def interpolate(data, x):
"""
Construct an interpolating polynomial for the data points.
**Examples**
>>> from sympy.polys.polyfuncs import interpolate
>>> from sympy.abc import x
>>> interpolate([1, 4, 9, 16], x)
x**2
>>> interpolate([(1, 1), (2, 4), (3, 9)], x)
x**2
>>> interpolate([(1, 2), (2, 5), (3, 10)], x)
x**2 + 1
>>> interpolate({1: 2, 2: 5, 3: 10}, x)
x**2 + 1
"""
n = len(data)
if isinstance(data, dict):
X, Y = zip(*data.items())
else:
if isinstance(data[0], tuple):
X, Y = zip(*data)
else:
X = range(1, n+1)
Y = list(data)
poly = interpolating_poly(n, x, X, Y)
return poly.expand()
def test_interpolating_poly():
x0, x1, x2, x3, y0, y1, y2, y3 = symbols('x:4, y:4')
assert interpolating_poly(0, x) == 0
assert interpolating_poly(1, x) == y0
assert interpolating_poly(2, x) == \
y0*(x - x1)/(x0 - x1) + y1*(x - x0)/(x1 - x0)
assert interpolating_poly(3, x) == \
y0*(x - x1)*(x - x2)/((x0 - x1)*(x0 - x2)) + \
y1*(x - x0)*(x - x2)/((x1 - x0)*(x1 - x2)) + \
y2*(x - x0)*(x - x1)/((x2 - x0)*(x2 - x1))
assert interpolating_poly(4, x) == \
y0*(x - x1)*(x - x2)*(x - x3)/((x0 - x1)*(x0 - x2)*(x0 - x3)) + \
y1*(x - x0)*(x - x2)*(x - x3)/((x1 - x0)*(x1 - x2)*(x1 - x3)) + \
y2*(x - x0)*(x - x1)*(x - x3)/((x2 - x0)*(x2 - x1)*(x2 - x3)) + \
y3*(x - x0)*(x - x1)*(x - x2)/((x3 - x0)*(x3 - x1)*(x3 - x2))
def inter_poly(X, Y, symbol = x, algo = 'Lr', simplify = True):
"""
polynomial interpolation using Lagrange's Methods
takes numpy array
"""
n = X.size
if algo == 'Lr':
poly = interpolating_poly(n, symbol, X, Y)
elif algo == 'Nt':
poly = interpolating_poly_Newton(n, symbol, X, Y)
elif algo == 'Nv':
poly = interpolating_poly_Neville(n, symbol, X, Y)
if simplify == True:
poly = poly.expand()
return poly
def interpolate(data, x):
"""
Construct an interpolating polynomial for the data points.
Examples
========
>>> from sympy.polys.polyfuncs import interpolate
>>> from sympy.abc import x
A list is interpreted as though it were paired with a range starting
from 1:
>>> interpolate([1, 4, 9, 16], x)
x**2
This can be made explicit by giving a list of coordinates:
>>> interpolate([(1, 1), (2, 4), (3, 9)], x)
x**2
The (x, y) coordinates can also be given as keys and values of a
dictionary (and the points need not be equispaced):
>>> interpolate([(-1, 2), (1, 2), (2, 5)], x)
x**2 + 1
>>> interpolate({-1: 2, 1: 2, 2: 5}, x)
x**2 + 1
"""
n = len(data)
if isinstance(data, dict):
X, Y = zip(*data.items())
else:
if isinstance(data[0], tuple):
X, Y = zip(*data)
else:
X = range(1, n + 1)
Y = list(data)
poly = interpolating_poly(n, x, X, Y)
return poly.expand()
def interpolate(data, x):
"""
Construct an interpolating polynomial for the data points.
Examples
========
>>> from sympy.polys.polyfuncs import interpolate
>>> from sympy.abc import x
A list is interpreted as though it were paired with a range starting
from 1:
>>> interpolate([1, 4, 9, 16], x)
x**2
This can be made explicit by giving a list of coordinates:
>>> interpolate([(1, 1), (2, 4), (3, 9)], x)
x**2
The (x, y) coordinates can also be given as keys and values of a
dictionary (and the points need not be equispaced):
>>> interpolate([(-1, 2), (1, 2), (2, 5)], x)
x**2 + 1
>>> interpolate({-1: 2, 1: 2, 2: 5}, x)
x**2 + 1
"""
n = len(data)
if isinstance(data, dict):
X, Y = zip(*data.items())
else:
if isinstance(data[0], tuple):
X, Y = zip(*data)
else:
X = range(1, n + 1)
Y = list(data)
poly = interpolating_poly(n, x, X, Y)
return poly.expand()
def test_interpolating_poly():
x0, x1, x2, x3, y0, y1, y2, y3 = symbols('x:4, y:4')
assert interpolating_poly(0, x) == 0
assert interpolating_poly(1, x) == y0
assert interpolating_poly(2, x) == \
y0*(x - x1)/(x0 - x1) + y1*(x - x0)/(x1 - x0)
assert interpolating_poly(3, x) == \
y0*(x - x1)*(x - x2)/((x0 - x1)*(x0 - x2)) + \
y1*(x - x0)*(x - x2)/((x1 - x0)*(x1 - x2)) + \
y2*(x - x0)*(x - x1)/((x2 - x0)*(x2 - x1))
assert interpolating_poly(4, x) == \
y0*(x - x1)*(x - x2)*(x - x3)/((x0 - x1)*(x0 - x2)*(x0 - x3)) + \
y1*(x - x0)*(x - x2)*(x - x3)/((x1 - x0)*(x1 - x2)*(x1 - x3)) + \
y2*(x - x0)*(x - x1)*(x - x3)/((x2 - x0)*(x2 - x1)*(x2 - x3)) + \
y3*(x - x0)*(x - x1)*(x - x2)/((x3 - x0)*(x3 - x1)*(x3 - x2))
raises(ValueError, lambda: interpolating_poly(2, x, (x, 2), (1, 3)))
raises(ValueError, lambda: interpolating_poly(2, x, (x + y, 2), (1, 3)))
raises(ValueError, lambda: interpolating_poly(2, x + y, (x, 2), (1, 3)))
raises(ValueError, lambda: interpolating_poly(2, 3, (4, 5), (6, 7)))
raises(ValueError, lambda: interpolating_poly(2, 3, (4, 5), (6, 7, 8)))
assert interpolating_poly(0, x, (1, 2), (3, 4)) == 0
assert interpolating_poly(1, x, (1, 2), (3, 4)) == 3
assert interpolating_poly(2, x, (1, 2), (3, 4)) == x + 2
def interpolate(data, x):
"""
Construct an interpolating polynomial for the data points
evaluated at point x (which can be symbolic or numeric).
Examples
========
>>> from sympy.polys.polyfuncs import interpolate
>>> from sympy.abc import a, b, x
A list is interpreted as though it were paired with a range starting
from 1:
>>> interpolate([1, 4, 9, 16], x)
x**2
This can be made explicit by giving a list of coordinates:
>>> interpolate([(1, 1), (2, 4), (3, 9)], x)
x**2
The (x, y) coordinates can also be given as keys and values of a
dictionary (and the points need not be equispaced):
>>> interpolate([(-1, 2), (1, 2), (2, 5)], x)
x**2 + 1
>>> interpolate({-1: 2, 1: 2, 2: 5}, x)
x**2 + 1
If the interpolation is going to be used only once then the
value of interest can be passed instead of passing a symbol:
>>> interpolate([1, 4, 9], 5)
25
Symbolic coordinates are also supported:
>>> [(i,interpolate((a, b), i)) for i in range(1, 4)]
[(1, a), (2, b), (3, -a + 2*b)]
"""
n = len(data)
if isinstance(data, dict):
if x in data:
return S(data[x])
X, Y = list(zip(*data.items()))
else:
if isinstance(data[0], tuple):
X, Y = list(zip(*data))
if x in X:
return S(Y[X.index(x)])
else:
if x in range(1, n + 1):
return S(data[x - 1])
Y = list(data)
X = list(range(1, n + 1))
try:
return interpolating_poly(n, x, X, Y).expand()
except ValueError:
d = Dummy()
return interpolating_poly(n, d, X, Y).expand().subs(d, x)
