# [Edu-sig] number-line graphics for teaching arithmetic

Kirby Urner pdx4d@teleport.com
Thu, 28 Dec 2000 23:34:06 -0800

```Hi Fred --

Your number line program sounds like fun -- especially for
the person learning a programming language.  For a 7 year
old, it might be just as instructive to use felt pens or
colored pencils though.

As mentioned at my "Getting Inventive with Vectors" at
http://www.inetarena.com/~pdx4d/numeracy1.html , I like to
go for a more complete vector concept, and not make the number
line too front and center initially.  Space first, planes
and lines second, is my approach (take freedoms away later,

The way the curriculum is now, we associate numbers with
lengths, and then take this away later, saying you need
vectors to extend in space, whereas the real numbers only
*scale* vectors (are not independently geometric).

So to kids, it seems like real numbers start out acting like
vectors, but then vectors come along and start doing the
number line thing like they've already been doing -- but
now using this new terminology.  Confusing.  Recapitulates
the historical sequence (Euclid -> Grassmann) more than
presents a coherent conceptual logic.[1]

The idea of translating a pencil through space without rotation
should be communicable to a 7 year old.  If it slides around
in space without change in orientation, that's what we call
translation (I bet with whole body movements the idea of
motion without rotation would get across -- e.g. have kids
slide across the room without changing the direction they're
facing).

So you have a bunch of these pencils pointing in various directions
(various lengths too, if you like), and you get to slide them
anywhere so long as you don't change direction.  Put them
tip-to-tail and that's what we mean by "adding the pencils"
(or call them arrows -- then it's just a short step to "vectors"
-- as a key term).

Here, a computer could be helpful, giving a graphical notion
of different segments adding up tip-to-tail.  It's hard to hold a
lot of pencils in space.  Pictures help.

You could talk about a swimming sea turtle that swallowed a die
(random chooser device).  At each turn to play, it could pick
any of the (6) plus/minus XYZ vectors and move in that direction,
with each hop being a segment (a tail-to-tip interval corresponding
to a pencil in the above discussion):

>>> import turtles, povray, functions     # Python 101 modules
>>> myfile = povray.Povray("ocean.pov")   # open a povray file
>>> seaturt = turtles.Turtle(turtles.xyzrays(),myfile) # xyz freedoms
>>> seaturt.randomwalk(10)          # take 10 random hops
>>> functions.xyzaxes(myfile,3)     # add xyz axes to picture
>>> myfile.close()                  # close file
>>> myfile.render()                 # render (or do it manually)

Result: http://www.inetarena.com/~pdx4d/ocn/graphics/ocean.gif
(notice how the turtle back-tracks at one point).

Because these kids start in space, they already know what a
tetrahedron and an icosahedron are too, and so you can intelligibly
have your turtle swim in one of the 4 directions defined by the
tetrahedron's 4 vertices (or one of the icosahedron's 12).
The turtles.py module already defines tetrays and icorays
for this purpose.

See "Random Walks in the Matrix":
http://www.inetarena.com/~pdx4d/ocn/numeracy3.html

Once a fully spatial sense is developed, THEN I'd reduce it to
a single line on which you can only point left or right (or whatever
we call the two directions (your left or my left?)).  I do it
this way because I think space/volume is actually more natural
and easier to understand than these artificially constrained
"number line" domains.

At this number line level, with degrees of freedom highly
(artificially) restricted, you could, if you wanted, do some
simple programming.  Maybe with slightly older kids.

For example (the methods in action):

>>> a = arrow(10)
>>> b = arrow(-5)
>>> c = arrow(8)
>>> d = arrow(-3)
>>> e = arrow(9)
>>> aprinter([a,b,c,d,e])
10  ---------->

-5  <-----

8  -------->

-3  <---

9  --------->

Result  19
>>> aprinter([a,c,d,d])
10  ---------->

8  -------->

-3  <---

-3  <---

Result  12

=========================
Simple source code behind the above:

def arrow(n):
line=''
if n<0:  line = '<'
line+=abs(n)*'-'
if n>0:  line += ">"
line += '\n'
return (n,line)

def aprinter(arrows):
sum = 0
for a in arrows:
print "%#3i  %s" % a
sum += a[0]
print "Result %#3i " % sum

[1]
http://www.maths.utas.edu.au/People/dfs/Papers/GrassmannLinAlgpaper/node1.html

```