Lab 4A - Arcs, Parametrizations, and Arclength
Math 2374 - University of Minnesota
http://www.math.umn.edu/math2374
Questions to: rogness@math.umn.edu

Introduction

In Lab 2A we worked with parametric equations and curves, which are also called "arcs."  In this lab we're going to examine these objects a little deeper.  We'll take a look at what the derivative of a parametrization is, and we'll also talk about arc length.  For most of these purposes we're going to use the unit circle, because you're already familiar with it, and yet it's complicated enough to illustrate many different concepts.

FYI:  In your textbook, "curve" and "arc" are defined to be the same thing.  In practice most of us will generally refer to these things as curves.  However when we deal with the length of a curve, we suddenly change terms and talk about arc length as opposed to curve length.  Apparently the term "arc length" is so deeply ingrained in mathematicians' brains that we'll never be able to switch!  Please don't get confused by this change in terminology.

One other reminder: a "path" is actually a function which is a parametrization for some curve.  Sometimes in an abuse of language we'll say "path" when we really mean "curve" and vice versa, but you should remember that there is a (subtle) difference!  (Ask your TA if you don't understand what the difference is.)

We're going to use some commands in this lab which are not normally part of Mathematica.  Two of the commands are part of a package from Lafayette College, and the other commands were written here at the University of Minnesota.  In order to use them, you must download the package "Arctools.m" from the main course webpage, http://www.math.umn.edu/math2374.  Once you've saved this file in your home directory, you can load the commands by evaluating the following command:

Needs["Arctools`"]

You must load the package before you run any of the commands below!  We're going to use ParametricPlot in this lab, so let's also turn off those blue error messages about compiling functions:

Off[ParametricPlot::ppcom]

Now we can begin the lab.

The Derivative of a Parametrization

Suppose we have a parametrization f(t) = (x(t), y(t)), where t ranges from 0 to 10.  If we say that t represents time in seconds, then we can say f(t) represents the position of an object at time t.  For example, consider the following function:

f[t_] = {Cos[t], Sin[t]};

You should know by now that this is a parametrization for the unit circle.  As you learned in Lab 2A, you can plot this function using ParametricPlot:

ParametricPlot[f[t], {t, 0, 2  Pi}, 
      AspectRatio -> Automatic]

This doesn't give you a feel for what I'm telling you, however: that f(t) can be viewed as the location function for a particle moving around the unit circle, where the particle finishes its trip when t=2π seconds (or minutes, or hours, or whatever our unit is).

Try executing the following command.  It will produce an animation of the particle moving around, which is actually just a number of different pictures in rapid succession.  Your TA will demonstrate how to view the animation.

PathAnimate[f[t], {t, 0, 2  Pi}, 40]

Now you can see the particle moving around the curve.  It looks as if the speed of the particle is constant; let's see if we can prove that somehow.

Recall from section 1.10 in your textbook that if f(t) represents the location of a particle at time t, then v(t)=(f^′)(t), the derivative of f, represents the velocity of the particle at time t.  For example, in our case we have:

v[t_] = D[f[t], t]

Velocity is a little different than speed.  Speed is just a number representing how fast a particle is moving.  Velocity is a vector whose length represents speed, and whose direction represents the direction the particle is moving at that specific instance of time.

To see an animation of the particle moving around the circle along with its tangent vectors, run this command:

PathTangentAnimate[f[t], {t, 0, 2  Pi}, 40]

It certainly looks as if the length of the velocity vector is constant, which would confirm that the speed of the particle is constant.  In fact, we can show this algebraically.  You should find the length of the tangent vector v(t) on paper and show that it is constant -- it does not depend on t.

Let's look at a different parametrization of the unit circle,

g(t) = (Cos((t^2)), Sin((t^2)) ),	0≤t≤(Sqrt[2  π]).

This is a parametrization of the unit circle because as t ranges from 0 to (Sqrt[2  π]), (t^2) ranges from 0 to 2π:

g[t_] = {Cos[t^2], Sin[t^2]};
ParametricPlot[g[t], {t, 0, Sqrt[2  Pi]}, 
      AspectRatio -> Automatic]

Now let's watch the particle whose motion is represented by g[t]:

PathTangentAnimate[g[t], {t, 0, Sqrt[2  Pi]}, 40]

As you can see, the particle starts out very slowly and picks up speed as time goes on.  You can see this either by watching the particle itself, or by watching the length of the tangent vector grow.  (Remember, the length of the tangent vector represents the speed of the particle!)

You will be asked to explain what's going on in this parametrization down below in Exercise 2.

If you'd like to play around with these two animation commands, their syntax is:

PathAnimate[f[t],{t,tmin,tmax},n]
PathTangentAnimate[f[t],{t,tmin,tmax},n]

where n represents the number of frames to draw.  (So the bigger n is, the longer it takes to create the animation, but the smoother it looks.  40 seems to be a reasonable number for most parametrizations.  Here are a couple of parametrizations to try; you can copy these and paste them into commands:

f[t_]={Cos[t],Sin[t]^3}, {t, 0, 2Pi}		(at least 40 frames)
f[t_]={Cos[2t],Sin[3t]}, {t, 0, 2Pi}		(at least 50 frames)
f[t_]={Cos[2t],Sin[4t]}, {t, 0, 2Pi}		(at least 50 frames)
f[t_]={Cos[5t],Sin[3t]}, {t, 0, 2Pi}		(at least 100 frames)
f[t_]={t,t^2}, {t, -1,1}					(at least 30 frames)
f[t_]={t^3,t^2}, {t, -1,1}					(at least 30 frames)

Estimating Arc Length

During the rest of this lab, we will explore how to estimate the length of a curve by approximating the curve with line segments.  If this seems like a total subject change, it will all make sense in a bit; the accuracy of these estimates can be tied in with the tangent vector, which is why we examined that above.

To begin, we're going to use larger and larger numbers of line segments to estimate the length of the upper half of the unit circle.  We're using this particular curve because -- as you should definitely know by now -- the arc length of the upper half of the unit circle is π.

π is a very famous number which shows up everywhere.  You probably know that it is irrational, i.e. it cannot be represented as a fraction.  In fact, the decimal expansion of π goes on forever and ever, with no apparent pattern that we've been able to discern.  To 40 decimal places,

π = 3.141592653589793238462643383279502884197.

Historically, people have used many different approximations for π.  The ancient Egyptians and Babylonians both realized that it is slightly bigger than 3.  The Babylonians used an approximation of 3 (1/8) = 3.125, a bit low.  The Egyptians' estimate of  (256/81)≈ 3.16049 is too high.  In the fifth century, a Chinese mathematician named Tsu Chung Chi estimate π as (355/113)≈ 3.14159292, which agrees with the true value of π for six decimal places!

In high school you may have used approximations such as 3.14, or 3.14159, etc.  Your calculator probably has the correct value of π stored up to 100 digits or so, which is usually more than enough.  In fact, knowing π to just 39 decimal places is sufficient for calculating the circumference of the universe accurate to the radius of a hydrogen atom, but in recent years computer scientists have tried to calculate as many digits of π as possible.  By the mid 1990s we knew the value of π to more than 6 billion digits!  (If you'd like to know more about π, you could read a book called A History of π, written by Petr Beckman.)

For over one thousand years the most common method of  estimating π was due to Archimedes, who used it to calculate that 3 (10/71)≺ π ≺ 3 (1/7).  Essentially, part of his method was to do exactly what we're about to do: estimate the length of a circle using line segments.  Let's get started!

To plot the upper half of the unit circle along with 4 approximating segments, evaluate this command:

Segments[{Cos[t], Sin[t]}, {t, 0, Pi}, 4, 
      AspectRatio -> Automatic]

There is another command which will add up the lengths of these segments and give us an estimate of the arclength.

Estimate[{Cos[t], Sin[t]}, {t, 0, Pi}, 4]

You can tell that we're in the right ballpark, but still not very close!  In fact we need to use many more segments before we get anything close to an accurate estimate.  For his lower bound on π, Archimedes would have used about 48 line segments:

Segments[{Cos[t], Sin[t]}, {t, 0, Pi}, 48, 
      AspectRatio -> Automatic]
Estimate[{Cos[t], Sin[t]}, {t, 0, Pi}, 48]

Exercise 1

Find the minimum number n of segments required such that the estimate of π is accurate to five decimal places, i.e. such that the estimate is 3.14159.  You should hand in what you think the number n is, as well as the estimates with n segments and (n-1) segments.  (In other words, show that you've actually found the smallest such n.)  You do not need to hand in graphs of the line segments; once you use more than about 10 segments, the graph of the circle is nearly indistinguishable from the line segments anyway!

Arc Length and the Derivative

Earlier in this lab we used two different parametrizations for the unit circle.  You can redefine them here, just in case you've used the letters f or g for other functions since that part of the lab:

f[t_] = {Cos[t], Sin[t]};
g[t_] = {Cos[t^2], Sin[t^2]};

Let's look at what happens when we try to use these parametrizations to find the circumference (or arc length) of the unit circle.  Initially we'll use 12 line segments for picture.

With f(t), we'll get a picture similar to the one above when we used 4 segments to estimate the length of the upper half circle:

Segments[f[t], {t, 0, 2  Pi}, 12, 
      AspectRatio -> Automatic]
Estimate[f[t], {t, 0, 2  Pi}, 12]

(Remember, since we're using the whole circle, the length is really 2π ≈ 6.2831853.)

We get a nice symmetric picture, as we would expect.  But things are different if we use g(t).  Remember that t only goes to (Sqrt[2  π]) when we use g!

Segments[g[t], {t, 0, Sqrt[2  Pi]}, 12, 
      AspectRatio -> Automatic]
Estimate[g[t], {t, 0, Sqrt[2  Pi]}, 12]

As you can see, the picture is all out of whack, and the estimate is much worse than what we obtained using f(t).  The reason for this has to do with the first part of this lab, where we looked at particles whose position was described by f(t) and g(t).  

These pictures were obtained by dividing the time interval into 12 equal pieces; each blue segment represents the movement of the particle during one of those subintervals.  The first picture is symmetric because a particle moving according to f(t) has constant speed.  The second picture is uglier because a particle moving according to g(t) picks up speed as time passes, so it moves further during each successive subinterval.

That last paragraph is a little dense, but you should re-read it until you understand it because it holds the key to understanding how the derivative relates to the accuracy of given estimations.  Once you understand what's happening for these pictures, you are ready for problem 2.

Exercise 2

In this problem we'll work with the same two parametrizations for the unit circle,

f(t) = (Cos(t),  Sin(t)),	0≤t≤2π
g(t) = (Cos((t^2)), Sin((t^2)) ),	0≤t≤(Sqrt[2  π]).

(a)  Calculate the length of the tangent vector using the first parametrization.  (You did this earlier.)

(b)  Do the same for the second parametrization.  (Simplify your answer!)

(c)  Look at the pictures above where the circumference is estimated using 12 segments with each parametrization.  Although the estimate using g(t) is clearly the worse of the two, if you look in the first quadrant it's another story.  If you were to add up the lengths of the line segments in the first quadrant of each picture, thereby estimating (π/2), it appears that you'd get a better estimate from the second picture, which was made using g(t)!

Confirm this and explain why it is so!  

Hint: to confirm it you can use Segments and Estimate to analyze the quarter circle, but you need the correct number of segments and the correct domain for for each parametrization.  To explain why it is so will take some thought, and we expect you to present a clear explanation of what's going on -- something beyond "the Estimate command shows that it is more accurate."

Dangerous Curve Ahead

In this last part of the lab we'll examine a curve whose length can be tricky to estimate.  The following is a parametrization of the curve:

h[t_] = {Cos[t],  Sin[t] + 0.01 Sin[1000  t]}

(For our purposes we'll assume 0≤t≤π.)

First use the command Segments with 100 segments to sketch the curve and the approximating segments.  Then use Estimate with 100 segments to calculate the approximate length.  Do you think this is accurate?  (You can use the following commands.)

Segments[h[t], {t, 0, Pi}, 100];
Estimate[h[t], {t, 0, Pi}, 100]

You should also try Estimate with 250, 500, and 1000 line segments.  You should be building a large amount of evidence that the arc length of this curve is π.  Again, do you think this is accurate?

Now that you're comfortable with this estimate, try using Estimate with 950 segments.  If you've done everything correctly, you should be thinking, "Huh?" when you see the answer.  Now which estimate do you think is the most accurate?

To find out, let's examine a tiny little piece of the curve.  Instead of letting t range from 0 to π, let's look at the section where 0≤t≤(π/50).  1000 segments over the whole curve corresponds to 1000/50=20 segments on this tiny piece of the curve.

Segments[h[t], {t, 0, Pi/50}, 1000/50]

Remember, the curve is red, while the approximating line segments are blue.  Now do you understand what's going on?  Look at this tiny piece with 950/50=19 segments instead of 20 segments.  Which estimate is more accurate?

Exercise 3

Experiment with the number of line segments on the small piece of the curve until you think you have an accurate estimation of the arc length.  Then multiply by 50 to find the corresponding number of line segments on the entire curve, and use this to find an estimation of the total arc length.

You should hand in your estimate, the number of segments used, and a picture of this estimate at the "tiny" level (where 0≤t≤(π/50)) so we can see how good the fit is.

Exercise 4

(a)  Suppose you have a parametrization f(t) (with some bounds on t) for a given curve.
Now suppose you find the following estimates of the curve's length:

100   segments: length ≈ π.
1000 segments: length ≈ π.
850  segments: length ≈ 400.

Can you tell which number of segments gives the most accurate estimate?  Why?

(b)  Suppose now your estimates look like this:

100   segments: length ≈ π.
1000 segments: length ≈ π.
850  segments: length ≈ 1.

Now can you tell which number of segments gives the most accurate estimate?  Why?  (Has your answer changed?)

Credits

This lab is a substantial rewrite of the old Arc Length lab, which was actually written in LATEX.  Exercises 1 and 3 are the same, but the text surrounding them has been completely changed.  The introduction and the section with the animations are new as well.  In other words, this lab was basically written from scratch, except for two of the exercises.
 
The old exercise 2 went something like this: start with two completely different arcs, and estimates of their lengths.  If you evaluate the derivatives at the point t=π/2 for each parametrization, you find that the second arc's tangent vector is longer than the other.  From this the students were asked to extrapolate that the arc length estimate of the second curve is less accurate.  At best this wasn't the whole story; at worst it's an incorrect claim.  In any case, I hope the current exercise 2 does a better job.

"Segments" and "Estimate" are part of a package used in the old lab.  Evidently this package was from Lafayette, although I haven't found any references to it at Lafayette's web site.  I wrote the animation commands in January 2002, and combined them into a new Arctools packages with the other two commands.  To avoid licensing issues I may go back and write new versions of these commands.

As always, please send me any questions or comments!

Copyright 2002,2003 by Jonathan Rogness (apart from the Lafayette Package)
Licensed under GNU GPL to the University of Minnesota School of Mathematics.
rogness@math.umn.edu