[Edu-sig] Re: catenaries vs. parabolas

Tue, 02 May 2000 15:27:55 -0700

Earlier today, Adam Stinchcombe wrote:
>Not one suspension bridge in the world was built without a precise 
>mathematical understanding of the shape of Martha's hanging chain.  
>This might be an interesting thing to look into, and if I have 
>the time, I'll get back to the group about my findings.  Dating 
>the catenary to the famous Bernoullis is easy enough. 

Some of you researching this interesting topic have probably found:

http://www-groups.dcs.st-andrews.ac.uk/~history/Curves/Catenary.html

Plus students might need more background re cosh (hyperbolic
cosine):

http://www.ping.be/~ping1339/hyp.htm#The-hyperbolic-funct

Less directly math-oriented, but still part of our technological 
world, I also consider the following to be relevant:

   http://consumerlawpage.com/article/overhead.shtml 

(about kids electrocuting themselves on the overhead catenary
lines, and Conrail paying damages, for gross negligence in
this regard).

This is because of my "math as storyteller" model, i.e. using 
math to "connect the dots" in a more narratively-based 
format.[1]

I.e. getting into the railroading business is a good excuse to:

   (a) study the etymology of "catenary" (first use of the 
   term attributed to Christiaan Huygens, 1629-1695) and then 

   (b) look at the application and the dangers associated 
   therewith (perhaps even useful reinforcement for survival 
   reasons, if your students live in urban areas

Plus trains are going to come up elsewhere, maybe metaphorically
(as in "great circle railroad tracks") i.e. when we study networks 
(graph theory), transportation problems etc.  The idea is to 
"overload" these dips into trains with a lot of "extraneous" 
lore -- partly so that students attention remains entrained 
(because we're talking about more than "just the math", are
weaving in a lot of culture).

More good train imagery:
http://lackawanna.railfan.net/hoboken4.htm 
http://www.info-4u.com/modelmemories/polepic.htm
http://www.railway-technology.com/contractors/electrification/

Note: especially important is the pantograph, which maintains 
contact with the wire to maintain contact with the line, which 
is only very shallowly catenary (i.e. dips up and down with 
far less amplitude than an overhead telephone line).

I think what's obvious from my approach is that the web is 
making a difference.  This is in support of my thesis, 
advanced on the AMTE listserv:  that textbooks need to be
supplemented with cyberspace materials if we're to keep 
math relevant.  

This is because the "upgrade cycle" as inertially weighed 
down by the very slow-turning wheels of the mass-publishing 
industry is simply unable to keep pace -- and kids know this, 
at least intuitively.  We need to use cyberspace to drive
the upgrade cycle more quickly, and bring the curriculum
back into synch with the real world.

A textbook publisher could never afford the time, space (or 
expensive permissions) associated with diving into "trains" 
or "suspension bridges" in any great detail, as we're 
passing through the catenary topic (not a big focus --
the whole "curves" topic is a pale shadow of what it
used to be).  

A few word problems, with a shred of realism attached, is 
about all there's room for in your standard text book.  
But with the web, teachers are in position to _source_ a 
lot of new curriculum, simply by using a search engine
and some imagination.  

As educators can go where no text book publisher would 
or could -- and we should, because this is a way to 
help satisfy the deep hunger for relevant content which 
many kids feel.

Also on AMTE, I circled over-reliance on calculators as
symptomatic of curriculum impoverishment.  Computers do 
so much more, are easier to program, give us access to 
alpha/character-focused algorithms (e.g. "Hamming Distance"), 
plus get us "beyond flatland" (off the XY plane).  

I don't mind using the calculator interface as a useful 
guide to what are the most important primitive functions, 
distilled over the centuries.  Let's tour all the keys 
and figure out what they do (including the hyperbolic 
trig stuff -- on most scientific calculators).

But let's not _stop_ with the calculator for gosh sakes.  
At least one programming language should be a part of 
every math-learning course of study.  Numeracy and 
computer literacy are convergent goals.

And so here's another reason not to rely too heavily on
text books:  they're largely out of date on the computer
front, stuck back in the days of BASIC or Logo, missing 
the object-oriented boat, which is where objects like 
Vectors (even Quaternions) come into their own.  

We just can't afford to wait another five years for 
McGraw-Hill to finally come out with its Python-focussed 
math ed series (if that's even on the drawing board -- 
not saying I really know (I used to work in McGraw-Hill's
K-12 computer department, but that was over 15 years 
ago)).

Those of you familiar with my 'Numeracy + Computer Literacy'
pages know that I'm into using Python as an alternative
(self-executing) math notation.[2]  Python has easy syntax
and there's a growing body of literature aimed at 
communicating it to kids, including downloadable lessons
(linked from the For Further Reading section at the 
bottom of Part 1 of my 4-part essay).

Using Python, we could explore the catenary as follows:

>>> import math     # native module
>>> math.e          # contains built-in value for e
2.71828182846
>>> math.cosh(10)   # as well a built-in hyperbolic cosine
11013.2329201
>>> def newcosh(n): # ... but let's define our own (using e)
	return (math.e**n + math.e**(-n))/2.0

>>> newcosh(10)     # ... and confirm: same result
11013.2329201

Given a function is a set of (domain, range) pairs, we'd 
like to pass a domain to catenary() and get back a set 
of tuples (pairs):

>>> def catenary(domain,a):
       # accept list of domain values, constant a, 
       # return (domain,range) pairs of corresponding
       # catenary function
	pairs = []
	for x in domain:  # for each member of domain...
           range = math.cosh(x/a)  # ... compute range
	    pairs.append((x,range)) # append tuple
	return pairs

>>> def mkdomain(low, high, interval):
       # create list of domain values, from low to high
       # stepping by interval
       output = []     # the output list
       i=0
       while 1:        # just keep looping...
          output.append(low + i*interval)
          i=i+1
          if output[-1]>=high: break # ...until high reached
       return output

>>> domain = mkdomain(-1.0,1.0,0.1)
>>> domain
[-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 
0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

So let's get the tuples for this function, with some value 
for a:

>>> function = catenary(domain,0.5)  # a = 1/2
>>> function
[(-1.0, 3.76219569108), (-0.9, 3.10747317632), (-0.8, 2.57746447119), 
(-0.7, 2.15089846539), (-0.6, 1.81065556732), (-0.5, 1.54308063482), 
(-0.4, 1.3374349463), (-0.3, 1.18546521824), (-0.2, 1.08107237184), 
(-0.1, 1.02006675562), (0.0, 1.0), (0.1, 1.02006675562), 
(0.2, 1.08107237184), (0.3, 1.18546521824), (0.4, 1.3374349463), 
(0.5, 1.54308063482), (0.6, 1.81065556732), (0.7, 2.15089846539), 
(0.8, 2.57746447119), (0.9, 3.10747317632), (1.0, 3.76219569108)]

Now of ourse we'll eventually want to graph the thing.  Here's 
how I do it, using Python + Povray:

>>> import functions, povray     # add more tools to our namespace
>>> catpix = povray.Povray("mycat.pov")  # open a draw file
>>> functions.xyzaxes(catpix,3)  # output some colorful xyz axes
>>> graphit(function,catpix)     # see note [3] for more detail
>>> catpix.close()               # close the file

And here's the picture I get, using tools developed at my website:

  http://www.inetarena.com/~pdx4d/ocn/graphics/catenary.gif

Kirby

PS:  http://www.bfi.org/catenary.htm is also relevant (and closer 
to "home" (cite "ET math"))

NOTES:  

[1] http://fire1b.math.utk.edu/hypermail/mathedcc/0011.html
    or, after May 31, 2000 try:
    http://fire1b.math.utk.edu/hypermail/mathedcc/may00/0011.html
[2] http://www.inetarena.com/~pdx4d/ocn/cp4e.html#python
[3] Here's my graphit function:

>>> def graphit(myfunc, myfile):
      for i in range(len(myfunc)-1):
          v1 = Vector((myfunc[i][0],myfunc[i][1],0))
          v2 = Vector((myfunc[i+1][0],myfunc[i+1][1],0))
          myfile.edge(v1,v2)   # draw edge between the two

makes use of a Vector class in coords.py module.

More background info re vector algebra w/ Python at:
http://www.python.org/pipermail/edu-sig/2000-May/000380.html
http://www.python.org/pipermail/edu-sig/2000-May/000381.html