Q: What is a parametrization?
A: This is a way to write a function so that all the coordinates
(or variables) depend on the same variable. By way of example,
then, if you have a function z = f[x,y], and if the parameter
is "t" where the x-coordinate is expressible as g[t], and
the y-coordinate is expressible as h[t], we say we can write
the function coordinate-wise as {x[t], y[t], z[t]}. One big
advantage here is that instead of worrying about two input
variables (x and y), we have reduced the function to one
input variable (t).
Q: Why haven't we seen much parametrization before now?
A: Because it isn't _usually_ too big a help until you
run into 3-dimensions or higher. For example, when
you write y = 3x, the coordinates to graph this one
are (x,y) which is the same as (x,3x), meaning that all
functions of the form y = f[x] are already "parametrized",
with parameter "x". That doesn't meanthere aren't other
parametrizations that would be more helpful, it just means
there haven't been too many reasons to have you look at them
before now.
Q: How do we parametrize certain things on our own?
A: Let me break this down into different parts:
A1: Circles and Ellipses
A2: Line Segments and Lines
A3: Miscellaneous
A1: Circles and Ellipses
Most of these involve the same idea, based on our favorite
Trig Identity: Substitute x[t] for x, and y[t] for y, and
remember that (Cos[t])^2 + (Sin[t])^2 = 1. Recall that the
unit circle can be written as x^2 + y^2 = 1. So one way to
parametrize the unit circle is {Cos[t],Sin[t]} with t going
from 0 to 2Pi. (There are many other ways to parametrize the
unit circle. The one given is the "canonical" or "usual" one.
One alternative (of zillions) is {-Sin[t],-Cos[t]} with t going
from 0 to 2pi.)
Which parametrization works for x^2 + y^2 = 4? Since we need
to get a "4" on the right side, how about trying x[t] = 2*Cos[t]
and y[t] = 2*Sin[t] (and let t go from 0 to 2pi)?
When you verify that one works, think about this: How would you
parametrize x^2 + y^2 = r^2, the circle of radius r centered at
the origin?
What if the circle isn't centered at the origin? Shift the
coordinates so it works anyhow. For example, the circle of
radius 10 centered at the point (3,5) is generally written
(x - 3)^2 + (y - 5)^2 = 100. To parametrize, we'd love to use
our favorite Trig Identity somehow, so let's choose
x[t] = 10*(Cos[t] + 3) and y[t] = 10*(Sin[t] + 5).
(Test it - it works.)
This idea also helps you figure out how to parametrize
ellipses centered anywhere you want, too. For example, to
parametrize the ellipse (x/2)^2 + ((y-1)/3)^2 = 1, choose
x[t] = 2*Cos[t] and y[t] = 3*Sin[t] +1. Does that make sense?
It all goes back to (Cos[t])^2 + (Sin[t])^2 = 1 and what you need
to plug in for x[t] and y[t] to get that equation back.
A2: Line Segments and Lines
As with circles and ellipses, there are several ways to do this.
Here is the canonical way, shown as one examples
parametrize the line segment "L" between points (a,b) and (d,e):
L = {(d - a)t + a, (e - b)t + b} with t going from 0 to 1.
That is, x[t] = (d - a)t + a and y[t] = (e - b)t + b, and we
let t go from 0 to 1.
This idea works in higher dimensions as well. For example:
parametrize the line segment "L" between (a,b,c) and (d,e,f):
L = {(d - a)t + a, (e - b)t + b, (f - c)t + c} with t going
from 0 to 1. That is, x[t] = (d - a)t + a, y[t] = (e - b)t + b,
and z[t] = (f - c)t + c, and we let t go from 0 to 1.
For entire lines, parametrize any segment on the line you wish,
then let t go from minus infinity to infinity.
A3: Miscellaneous
If you have a curve that is really different pieces of different
curves that have ben glued together (e.g. a square, views as four
line segments glued together), you can parametrize each piece
separately. then shift the parametrizations so the parameter
values run consecutively (e.g. so that piece one runs for t going
from 0 to 1, piece 2 then runs for t going from 1 to 2, etc.)
The shift involved is very very similar to the way we handled
the different centers in the Circles and Ellipses section.
Most other curves not covered above generally have to be handled
on a case-by-case basis.
Q: Okay, so these are helpful things sometimes. Why not all the time?
A: Two warnings that help answer this one:
1) You almost never graph the parameter axis. You're almost always
graphing the coordinate (output) variables only. This makes it
hard to look at the graph of a parametrized curve and be able to
spot a point and say "this is where t = 5" or something like that.
(i.e. If you parametrized the unit circle as {Cos[t],Sin[t]},
you'd still only graph the x and y axes to show the circle.
Even with knowledge of trig, it's hard to point at a random
point on the circle and say "t = <whatever>" there.)
2) As hinted at above in a couple different places, there are usually
_several_ ways to parametrize something. For example, the line
segment "L" from the point (0,0) to (1,2) can be parametrized in
a zillion ways, here being a mere eight of them:
a) L = {t,2*t} with t going from 0 to 1
b) L = {t^2, 2*t^2} with t going from 0 to 1
c) L = {t - 3, 2t - 6} with t going from 3 to 4
d) L = {Sin[t],2*Sin[t]}, with t going from 0 to Pi/2
e) L = {Sin[t],2*Sin[t]}, with t going from 2Pi to 5Pi/2
f) L = {-Sin[t],-2*Sin[t]}, with t going from Pi to 3Pi/2
g) L = {Sin[2t], 2*Sin[2t]} with t going from 0 to Pi/4
h) L = {E^t - 1, 2*E^t - 2} with t going from 0 to Log[2]
Basically, anything of the form {x[t], 2*x[t]} for t going from
a to b works, provided that x[a] = 0 and x[b] = 1.
While having several ways to parametrizing gives you many
options when you need to do it yourself, it also makes it
harder to pin down information on occasion because given a
function, you may not know which way it was already
parameterized or which way is best for you to do so yourself.
