Parametric interpolation in SciPy - Step-by-Step Execution

Concept Flow - Parametric interpolation

Input: Known points (x, y)

↓

Choose parameter t for each point

↓

Create interpolation functions for x(t) and y(t)

↓

Evaluate x(t_new), y(t_new) at new parameter values

↓

Output: Smooth curve through points

Parametric interpolation creates smooth curves by interpolating x and y coordinates separately as functions of a parameter t.

Execution Sample

SciPy

import numpy as np
from scipy.interpolate import interp1d

x = np.array([0, 1, 2, 3])
y = np.array([0, 1, 0, 1])
t = np.linspace(0, 1, len(x))

fx = interp1d(t, x, kind='linear')
fy = interp1d(t, y, kind='linear')

new_t = np.linspace(0, 1, 5)
new_x = fx(new_t)
new_y = fy(new_t)

This code creates linear parametric interpolation functions for x and y, then evaluates them at new parameter values to get interpolated points.

Execution Table

Step	Action	Variable/Function	Input	Output/Result
1	Define known points	x, y	x=[0,1,2,3], y=[0,1,0,1]	Arrays stored
2	Create parameter t	t	linspace(0,1,4)	[0.0, 0.3333, 0.6667, 1.0]
3	Create interpolation fx	interp1d(t,x)	t, x arrays	Function fx(t) created
4	Create interpolation fy	interp1d(t,y)	t, y arrays	Function fy(t) created
5	Define new_t	new_t	linspace(0,1,5)	[0.0, 0.25, 0.5, 0.75, 1.0]
6	Evaluate fx(new_t)	fx(new_t)	[0.0,0.25,0.5,0.75,1.0]	[0.0,0.75,1.5,2.25,3.0]
7	Evaluate fy(new_t)	fy(new_t)	[0.0,0.25,0.5,0.75,1.0]	[0.0,0.75,0.5,0.25,1.0]
8	Output interpolated points	new_x, new_y	from fx and fy	Arrays of interpolated points
9	End	-	-	Interpolation complete

💡 All new parameter values evaluated, interpolation finished

Variable Tracker

Variable	Start	After Step 2	After Step 5	Final
x	[0,1,2,3]	[0,1,2,3]	[0,1,2,3]	[0,1,2,3]
y	[0,1,0,1]	[0,1,0,1]	[0,1,0,1]	[0,1,0,1]
t	undefined	[0.0,0.3333,0.6667,1.0]	[0.0,0.3333,0.6667,1.0]	[0.0,0.3333,0.6667,1.0]
new_t	undefined	undefined	[0.0,0.25,0.5,0.75,1.0]	[0.0,0.25,0.5,0.75,1.0]
new_x	undefined	undefined	undefined	[0.0,0.75,1.5,2.25,3.0]
new_y	undefined	undefined	undefined	[0.0,0.75,0.5,0.25,1.0]

Key Moments - 3 Insights

Why do we create a parameter t instead of interpolating x and y directly?

We create t to treat x and y as separate functions of t, allowing smooth interpolation along the curve. See execution_table steps 2-4 where t is created and used to build fx and fy.

Why do new_x and new_y have more points than the original x and y?

Because we evaluate the interpolation functions at more parameter values (new_t) to get a smoother curve. See execution_table steps 5-7 where new_t has 5 points vs original 4.

What happens if new_t has values outside the original t range?

Interpolation functions may error or extrapolate depending on settings. Here, new_t stays within [0,1] to avoid that. See variable_tracker for t and new_t ranges.

Visual Quiz - 3 Questions

Look at the execution_table step 6, what is the value of fx at new_t=0.5?

A 0.5

B 2.0

C 1.5

D 1.0

💡 Hint

Check the output column in step 6 for fx(new_t) values.

At which step do we create the interpolation function for y?

A Step 4

B Step 5

C Step 3

D Step 6

💡 Hint

Look for 'Create interpolation fy' in the Action column.

If we change new_t to have 10 points instead of 5, what happens to new_x and new_y arrays?

A They remain with 5 points

B They will have 10 interpolated points

C They become empty arrays

D They will have 4 points

💡 Hint

Refer to variable_tracker for how new_t length affects new_x and new_y.

Concept Snapshot

Parametric interpolation:
- Use a parameter t for points
- Interpolate x(t) and y(t) separately
- Evaluate at new t for smooth curve
- Use scipy.interpolate.interp1d or similar
- Works well for curves not functions y=f(x)

Full Transcript

Parametric interpolation means we use a parameter t to represent points along a curve. We create interpolation functions for x and y coordinates separately as functions of t. Then we evaluate these functions at new t values to get smooth points along the curve. This method helps when y is not a function of x directly. The example code shows how to create t, build interpolation functions fx and fy, and get new points new_x and new_y. The execution table traces each step from defining points, creating t, building functions, to evaluating new points. Variable tracker shows how variables change. Key moments clarify why we use parameter t and how new points are generated. The quiz tests understanding of values and steps in the process.