
                      +--------------------------------+
                      |                                |
                      |  GALTON PROGRAM TUTORIAL FILE  |
                      |                                |
                      +--------------------------------+


The purpose of this file is to provide a tutorial lesson on most of the basic
features of the program called GALTON.  While it is possible to learn how to
use the program by reading all the built-in help screens contained within
each menu, if you are a first-time user, we suggest you read this tutorial
while first running the program, and then later you can digest all the
information contained in the help functions within each menu in the program.
You can import this file, GALTON.TXT, into any word processor and then print
it so you can read the hard copy output while you run the program.

To begin the tutorial you must have the program file GALTON.EXE.  We assume
this file is in the current directory on the currently selected disk drive.


PRELIMINARIES
=============


KEYBOARD CONVENTIONS
--------------------

As part of this tutorial we need to give directions on which keys to press on
your keyboard.  We will enclose in angle brackets single keystrokes that you
should type.  For example, if we ask you to type the first three letters
of the alphabet we will show <A> <B> <C>.  If we ask you to press the control
key, the alternate key, the backspace key, the space bar, or the enter (or
return) key, we will show <CTRL>, <ALT>, <BACKSPACE>, <SPACE> or <ENTER>.

Each enclosure in angle brackets should refer to exactly one keystroke or one
character.  On most keyboards, to type in a left or right parenthesis requires
using a <SHIFT> key in conjunction with another key.  We will NOT show the
shift key as a separate keystroke in this tutorial because we consider
entering a parenthesis as entering a single character.  Other characters like
<+> or <*> can be entered in two different ways on some keyboards, one way
uses the <SHIFT> key, the other way does not.  In general, we would only show
the single character in angle brackets and we leave it up to you to decide
whether or not the <SHIFT> is needed to enter the character.

These keyboard conventions should make clear exactly how many and which keys
you press.  If it is necessary to press two keys simultaneously we will show
a connecting plus sign between the keystrokes.  This is done primarily with
the Control key <CTRL>, and the Alternate key <ALT>.  For example, when we
show <ALT>+<X> it means you should press both the Alternate key and key X at
the same time.  <ALT>+<X> is used in the Main Menu to exit from the program.


DISPLAY STRINGS
---------------

We also need to indicate the contents of text strings you might see on the
display screen.  Such text parts will always be displayed in double quotes in
this tutorial file.  You will not see the double quotes on the screen, and the
screen may contain other text parts that we do not show in this file.  The
double quotes are simply a convenient way to indicate parts of what you may
see on the display.



ADVICE FOR NOVICES AND EXPERTS
------------------------------

This tutorial file assumes you have the mathematical background required to
understand the features that will be demonstrated.  You may find some sections
more applicable to novices than experts, or vice versa, depending on your
background and experience.  If you encounter an example that is beyond your
understanding, you can either skip that example, or you can press the keys and
view the results, even though you may not fully comprehend the output.  This
tutorial does not discuss techniques on how to best use or apply the available
features.  It only serves to demonstrate the basic features and capabilities
which you can learn to apply to solve problems that are of interest to you.



GETTING STARTED
===============

To begin running the GALTON program type the command:

                       <G> <A> <L> <T> <O> <N> <ENTER>



A FIRST EXAMPLE
===============

The program called GALTON simulates experiments in binomial probabilities.
The program is named after the inventor of what is called a GALTON board.
Francis Galton (1822-1911) used a board with equally spaced nails arranged in
rows, but staggered in a triangular arrangement with the triangle apex at the
top of the board.  In the program, the nails are called pegs, but in this
tutorial file we will use the term nails instead of pegs.

Objects are dropped across the maze of nails and filter through the nails
and then stack up in collection bins at the bottom of the board.

The objects that drop over the nails can be thought of as being either ping
pong balls or coins.  As an object hits each nail it has a given probability
of bouncing either left or right.

To demonstrate the basic operation of the board, press key

                                      <P>

in the main menu to begin performing a simulation.

You will see a simulated board in graphics mode.  The nails may appear as
small triangles and the default set-up run will simulate flat coins that
bounce left or right off each nail and spin falling down until they hit a
nail in the next row of nails.  The program makes a little ticking sound
as each coin bounces off each nail.

After watching the first few coins bounce across and down the screen, press
key

                                      <S>

to temporarily stop the simulation and enter what is called the Single Step
Mode.  A message on the screen will indicate you can press any key to
continue, but we will give preference to the ENTER key.

The action that will now be simulated is as if you had a stop-action camera
that records pictures of each bounce of each coin.

Continue to repeatedly press the      <ENTER>

key until you have moved several coins all the way through the maze of nails.
The coins fall by themselves once they get past the last row of nails.

The coins fall out of a vertical stack that appears at the top of the screen.
A counter indicates how many coins remain in the stack.

Press                               <ENTER>

to release the next coin.  As each coin leaves the stack it hits the first
nail at the apex of the triangle.  You then continue to press the

                                    <ENTER>

key to cause the coin to continue to fall.

After hitting a nail in the last row, the coin will automatically fall into
one of the collection bins.

You probably have some 200+ coins remaining, and rather than wait and watch
each of these fall one at a time, press key

                                      <A>

to go into the Automatic Mode and the coins should begin dropping very
rapidly.

Wait for the stack counter to reach 0.

When the coin stack empties, the program beeps and stops and displays the
counts of the coins in each collection bin.  After observing the numbers,
press

                                    <ENTER>

and the next screen should show the statistics associated with the run.  A
typical screen will look like the following, although the actual numbers you
generate will differ slightly from these.


+----------------------------------------------------------------------------+
|                                                                            |
|                       GALTON BOARD SIMULATION STATISTICS                   |
|                                                                            |
|  Number of Rows of Pegs = 8.            Number of Objects Dropped = 256.   |
|                                                                            |
|  X-values are numbers in the range -4. to 4. which represent bin numbers   |
|  such that the bins are centered about 0.                                  |
|  Y-values are the counts of the number objects deposited in the bins.      |
|                                                                            |
|  Statistic        X Values            Y Values            Expected Y Values|
|  =========        ========            ========            =================|
|  Maximum   =      4.                  69.                 70.              |
|  Mean      =      0.                  28.444444444        28.444444444     |
|  Minimum   =      -4.                 0.                  1.               |
|  Std. Dev. =      2.738612788         26.972722847        26.429676082     |
|                                                                            |
|  The Expected and Actual values of the 9 bin counts are:                   |
|                                                                            |
|E              1     8     28    56    70    56    28    8     1            |
|A              0     5     26    50    69    63    33    9     1            |
|                                                                            |
|  Expected values are based on the actual number of objects dropped.        |
|                                                                            |
|                          Press any key to continue                         |
|                                                                            |
+----------------------------------------------------------------------------+


While looking at the statistics text screen, you should note the two rows of
numbers that are marked with the letters E and A.  The E line represents the
Expected values, whereas the A line gives the Actual counts of the number of
coins that were deposited in the bins.

The expected values as represented by the E line are the numbers that are in
the 8th row of Pascal's Triangle.  It would be extremely rare for all 9
numbers in the second row to match the expected values.  However, the two rows
of numbers should be close, as in the above example.


Press                               <ENTER>

to return to the Main Menu.




A SECOND EXAMPLE
================

Press key                             <B>

to change the Board Display Option so that it shows "Coins Alone".

Then press key                        <P>

to perform another simulation.

This time you won't see the coins filter through the maze of nails.  The
simulation runs very fast and only shows the building up of the coin stacks
at the bottom of the screen.

When the simulation ends you will see the counts of the coins in each stack,
and the numbers will probably be different from your first run, but should
be somewhat close to the expected values in the 8th row of Pascal's Triangle.

Press                               <ENTER>

and you will see the statistics screen.

After viewing the statistics press

                                    <ENTER>

again to return to the Main Menu.

Now we will make a few more runs just so you can experience different sets of
numbers that get generated by the process.

Press key                        <P>

to perform another simulation.

When the run ends and the coin stack counts appear press

                                    <ENTER>

to generate and read the statistics screen.

After viewing the statistics press  <ENTER>

to return to the Main Menu.



Press key                        <P>

to perform another simulation.

When the run ends and the coin stack counts appear press

                                    <ENTER>

to generate and read the statistics screen.

After viewing the statistics press  <ENTER>

to return to the Main Menu.


By now you should have a fair idea of how the simulator works.



PING PONG BALLS INSTEAD OF COINS
================================

Assuming you are back in the Main Menu, press

                                      <O>

to change the object type from coins to ping pong balls.  The object type
should show

                              "Ping Pong Balls"

The only difference in the program when the object type is ping pong balls
is that you see little round balls as opposed to flat coins.

Press key                             <B>

twice to change the board display option to "Pegs & Bins".

Press key                             <P>

to perform another simulated run.

This time the collection bins are rather narrow, they only have to be wide
enough to hold the little balls, but the simulation will end prematurely
because one of the middle bins will eventually fill and overflow at its top.



                           "Bin Height Exceeded!"



When a collection bin overflows the simulation ends prematurely without
dropping all the remaining objects.  In this example there should be 256
balls total, but probably only about half of them got dropped before some bin
overflowed.

After reading the bin counts press

                                    <ENTER>

to read the statistics screen.

When overflow occurs the expected values are NOT the numbers in Pascal's
Triangle.  In this case the expected values are based on the actual number
of objects dropped.

After reading the statistics screen press

                                    <ENTER>

to return to the Main Menu.




CHANGING THE NUMBER OF ROWS OF OBJECTS
======================================

The problem with showing ping pong balls is that the bins can only hold a
few objects.  In fact, that is why the default mode of the program uses coins.
Coins are flat, and many more coins can be deposited and displayed in the
collection bins.

However, we can cure the ball overflow problem by changing the number of rows
of nails.

Press key                             <R>

and when prompted to enter a new number of rows, press

                                 <6> <ENTER>

In order to generate numbers from Pascal's Triangle, we need to set the number
of objects equal to the exact power of 2 that is represented by the number of
rows of nails.

So press                              <N>

to change the number of objects (in this case ping pong balls), and when
prompted, press

                               <6> <4> <ENTER>

Now press                             <P>

to perform another simulation.

This time you should see taller collection bins, because there are fewer rows
of nails, thus there is more room on the screen to display higher stacks of
balls.  Wait for all the balls to fall.

When the simulation ends you will see the bin counts as before, but now there
are only 7 bins.

Press                               <ENTER>

to see the statistics text screen.

This time you may note the Expected row of numbers from Pascal's Triangle
appears as


   "E                 1    6    15    20    15    6    1"





A NOVEL WAY OF GENERATING THE NUMBERS IN PASCAL'S TRIANGLE
==========================================================

To understand and gain an appreciation for the relationship between the
numbers in Pascal's Triangle and a binomial probability experiment, consider
the diagram below.

We begin the experiment with 64 balls in the top hopper.

All 64 balls fall and hit the top nail at the triangle apex.  In the diagram
below, each nail is represented by the marker ^, and the number above each ^
marker is the number of objects that reach or hit that nail.




                                      |  |
                                      |64|
                                       --
                                       |
                                       |
                                       |
                                       64
                     Row #1 --->       ^       <--- Row #1
                                      / \
                                     32 32
                                    /     \
                                   +       +
                                   |       |
                                   32      32
                 Row #2 --->       ^       ^        <--- Row #2
                                  / \     / \
                                 16 16   16 16
                                /     \ /     \
                               +       +       +
                               |       |       |
                               16      32      16
              Row #3 --->      ^       ^       ^       <--- Row #3
                              / \     / \     / \
                             8   8   16 16   8   8
                            /     \ /     \ /     \
                           +       +       +       +
                           |       |       |       |
                           8       24      24      8
         Row #4 --->       ^       ^       ^       ^       <--- Row #4
                          / \     / \     / \     / \
                         4   4   12 12   12 12   4   4
                        /     \ /     \ /     \ /     \
                       +       +       +       +       +
                       |       |       |       |       |
                       4       16      24      16      4
     Row #5 --->       ^       ^       ^       ^       ^       <--- Row #5
                      / \     / \     / \     / \     / \
                     2   2   8   8   12 12   8   8   2   2
                    /     \ /     \ /     \ /     \ /     \
                   +       +       +       +       +       +
                   |       |       |       |       |       |
                   2       10      20      20      10      2
 Row #6 --->       ^       ^       ^       ^       ^       ^       <--- Row #6
                  / \     / \     / \     / \     / \     / \
                 1   1   5   5   10 10   10 10   5   5   1   1
                /     \ /     \ /     \ /     \ /     \ /     \
               +       +       +       +       +       +       +
               |       |       |       |       |       |       |
               1       6      15      20      15       6       1



When an object hits a nail, it has a 50-50 probability of bouncing left or
right.  Assuming a perfect simulation, half of the original 64 balls will
bounce left, and half will bounce right of the first nail.  Thus we can assume
the first nail causes a splitting of the balls into two groups of 32 balls
each.

The two groups of 32 balls then hit the two nails in the second row of nails.
Half of each group bounce left and right of each nail.

Thus, below the 2nd row of nails we see the emergence of the 4 numbers 16, 16,
16, and 16.  But the two innermost 16's come together and get added as a total
of 32, which is the number of objects that reach the middle nail in the 3rd
row of nails.  The outer two nails in the 3rd row receive only 16 objects
each.

After the objects pass through the 3rd row of nails they get split into six
groups of 8, 8, 16, 16, 8, and 8 objects in the respective groups.  The outer
groups contain fewer objects than the inner groups.  But two of the inner
groups combine to form only four groups of 8, 24, 24, and 8, just before they
get slit across the 4th row of nails.

When the objects filter through the 4th row of nails they get split into eight
groups of 4, 4, 12, 12, 12, 12, 4, and 4 objects in the respective groups.  The
outer groups contain fewer objects than the inner groups.  Before arriving at
the 5th row of nails, these objects combine to form only 5 groups.

In terms of probability, we can understand why there is only one object in the
extreme positions in the last row.  If we were flipping coins, with 6 rows of
nails, then the one coin which reaches say the left-most collection bin, could
only have gotten there because it was flipped 6 consecutive times and came up
either heads or tails six times in a row.  This amounts to seeing HHHHHH or
TTTTTT.

We can also understand why the most number of objects appear in a symmetric
pattern about the middle collection bins.  Again in terms of flipping coins,
some coins may take on the pattern HTHTHT while others may look like THTHTH.
In any case, with 50-50 probabilities, after a couple of consecutive heads or
tails the next bounce will more likely be the opposite of what has just taken
place.



Press                               <ENTER>

to return to the Main Menu.




THE PYGMIE MODE
===============

So far we have demonstrated how to change the object type between coins and
balls, how to change the number of rows of nails, and how to change the
number of objects.

The last feature to be demonstrated is what is called the Pygmie Mode.

Press                                 <R>

to change the number of rows and when prompted press

                                 <5> <0> <ENTER>


If you now look at the Board Display Option it will show "Pygmie Mode".

Press                                 <N>

to change the number of objects, and when prompted press

                            <1> <0> <0> <0> <ENTER>

We are going to make a simulated run with 1000 objects dropping across a
board with 50 rows of nails.

Press                                 <P>

to begin performing the simulation.

The graphics screen will appear and this time you will not see round balls or
flat coins.  All that appears are tiny dots the size of one display screen
pixel (picture element).  The dot patterns build up, starting at the bottom
of the screen.
              
As the simulation continues to run you will note the emergence of a picture
that takes on the form of a histogram in which the top curve approximates
that of a standard bell-shaped normal Gaussian distribution.

It takes a little time for all 1000 objects to filter through the maze of
nails, but the program will sound a beep when the simulation ends.

When the simulation ends, press     <ENTER>

to see the statistics summary.  Whenever you have more than 12 rows of nails
the program does not show the expected bin counts, nor does it show the
actual bin counts.

Press                               <ENTER>

one more time to return to the Main Menu.

The Pygmie Mode is named as such because the objects are drawn as tiny screen
dots.  You will be forced to enter the Pygmie Mode whenever you set more than
12 rows of nails.  But you can also enter the Pygmie Mode by deliberately
changing the Board Display Option.




THE BOARD DISPLAY OPTION
========================

To change the Board Display option you would normally press key B from the
Main Menu.  However, the three normal choices are selectable only when the
number of rows of nails is 12 or less.  So if the program refuses to change
the board display option, it may be because you have more than 12 rows of
nails.  When this is the case, first change the number of rows to anything
less than 13, and then you can alter the board display option.




AN EXAMPLE OF A SKEWED-DISTRIBUTION
===================================

Our last example will show how to make a skewed distribution with the
program.

Assuming you are back in the Main Menu, press

                                      <R>

to change the number of rows, and when prompted press

                                  <8> <ENTER>

Then press                            <N>

to change the number of objects and when prompted press

                             <2> <5> <6> <ENTER>



Press                                 <O>

to change the object type to "Coins".


Finally, press                        <B>

twice to change the Board Display Option to "Coins Alone".

We have just set the program back to its start-up defaults, except we are not
going to show the complete board display.  This is perhaps the most-often
used mode when you wish to make quick simulated runs.


Now press                             <L>

to change the Left-Right probability.

You can set the probability of bouncing left or right to values other than
the default 50-50 value.  To make an example of a skewed distribution,
press
                                <7> <5> <ENTER>

This means 75% of the time the objects should bounce to the left of each nail.
This also implies 25% of the time they should bounce to the right of each
nail.

Press                                 <P>

to perform the simulation.

The graphics screen should show the collection stacks, but they will be
skewed to the left of the screen middle.

Press                               <ENTER>

to display the screen statistics.

This time the expected values are not the numbers in Pascal's Triangle,
because they have also been skewed.  The two right-most expected numbers are
0's!

Even though the distribution numbers are skewed, there should be a relatively
close match between the expected and the actual values.  Again it is rare to
have an exact match, but the patterns in the two rows of values should be
similar.

Press                               <ENTER>

again to return to the Main Menu.



CONTROLLING THE ACTION WHILE IN THE SINGLE STEP MODE
====================================================

When in the Single Step Mode with the full board displayed, you would normally
press the ENTER key to make each next move.  However, you can press either a
left or a right arrow key to force each next object to bounce left or right,
regardless of the values set for the Left-Right probabilities.  This option
can only be exercised in the Single Step Mode with the full board and objects
being displayed.  This feature is useful because you can control and perform
any exact sequence of bounces you wish to demonstrate.

The mode called the Demonstration Mode is somewhat similar to the Single Step
mode, the action is slowed down so you can see it, but the program does not
wait for you to press a key to continue.  Thus the Demonstration mode is a
continuous action mode.  When the pegs and bins are displayed you can press
any one of the three keys  A  D  S  to change to either the Automatic mode or
the Demonstration Mode, or the Single Step Mode.


CONCLUSION
==========

This concludes the GALTON program tutorial.  If you haven't done so already,
you can now read the help information contained within each main program menu
item.  Most of the basic features have been covered here, but you will gain
more insight by reading all the help information available to you.  If after
all this you still have questions, you can contact the author at the address
given below.


Press
                                   <ALT>+<X>

to quit and exit the GALTON program.


The GALTON program is periodically updated to make improvements, add new
features, (and sometimes to correct bugs!).  You may also wish to contact the
author to check if you have the latest version of the program.  The author
also invites your comments about how you liked the program and will consider
any suggestions you may wish to offer for making the program even more useful.



OTHER PROGRAMS
==============

If you enjoy using the GALTON program you may be interested to know there is
a whole suite of mathematical programs made by the author of GALTON.  These
programs are intended to help motivate an interest in mathematics and computer
science.  Some of the titles of these programs and a brief description of each
is given below.


 1. MATRIX - a program that teaches row operations with matrices.  Features
    include fraction mode, decimal mode, solves linear systems, inverses,
    determinants, sets of basis vectors, eigenvectors and eigenvalues,
    Gram-Schmidt orthogonalization, and the simplex algorithm.


 2. YFUNX - a program for graphing and analyzing functions in rectangular
    form, Y=F(X).  Includes coordinate trace and tangent/normal line modes,
    zooming in and out, scalable axes, graph parameter variable. Numerical
    integration features standard algorithms plus Gaussian Quadrature and the
    Romberg algorithm.  Animation features include plane areas, plane arc
    length, 3D volumes (disks & cylindrical shells) and 3D surface areas.
    Newton's method and the method of successive bisections are for solving
    F(X)=0.  Automatically finds maximum/minimum extrema.  All algorithms
    may be demonstrated in either graphics or text modes.


 3. POLAR - a program for graphing and analyzing functions in polar form,
    R=F(@) or R^2=F(@).  Similar to YFUNX, includes coordinate trace and
    tangent/normal line modes, zooming in and out, scalable axes, and a graph
    parameter variable.  Numerical integration for polar areas and arc length.
    Automatically finds maximum/minimum extrema over any section of a curve.


 4. PARAM - a program for graphing and analyzing functions in parametric form,
    X=F(T) and Y=G(T).  Similar to YFUNX, includes coordinate trace and
    tangent/normal line modes, zooming in and out, scalable axes, and a graph
    parameter variable.  Numerical integration calculates plane areas and arc
    length.  Automatically finds maximum/minimum extrema over any section of
    a curve.


 5. POLPM - a program for graphing and analyzing functions in polar
    coordinates, but that have been parametrized, say R=F(T) and @=G(T).
    Similar to the POLAR and PARAM programs, this program includes coordinate
    trace and tangent/normal line modes, zooming in and out, scalable axes,
    and a graph parameter variable.  Numerical integration for plane areas
    and arc length.  Automatically finds maximum/minimum extrema over any
    section of a curve.


 6. DIFEQ - a program related to 1st order differential equations.  Includes
    graphing the direction field and solves initial value problems using
    Euler methods and a 4th order Runge-Kutta method.  Includes coordinate
    trace mode, zooming in and out, and scalable axes.  Algorithms may be
    demonstrated in either graphics or text modes.


 7. CURVE3D - a program for making 3D graphs of curves given in the parametric
    form X=f(t), Y=g(t), and Z=h(t).  The resulting curve may be viewed from
    any position, and the drawing is a true-perspective 3D picture.


 8. SURF3D - a program to graph 3-dimensional surfaces of the form Z=F(X,Y).
    The resulting surface may be viewed from any position, and the drawing is
    a true-perspective 3D picture.  The surface may be displayed using lines
    of constant x, or constant y, or a fishnet.  Included is a hidden line
    algorithm for more realistic pictures.


 9. CFIT - a program which performs curve fits to data.  Includes linear
    regression for linear, exponential, logarithmic, and power functions.
    Graphs scatter diagrams and the fitted function curves and performs
    a statistical analysis, including an automatic best fit selection.  Data
    may be saved to or read from disk files.


10. GALTON - simulates coin tossing experiments related to probabilities and
    demonstrates graphically how the binomial distribution is related to the
    standard normal Gaussian bell-shaped curve.  Also compares stack counts
    with the numbers generated in Pascal's Triangle.  Either coins or
    ping-pong balls may be used in simulated experiments.  Variable number of
    rows of pegs, variable number of objects, variable left-right probability
    for generating skewed distributions.  Includes a single-step mode under
    full user control.


11. BUFFON - simulates needle dropping experiments related to probabilities
    used to approximate the number Pi.  Needles are randomly dropped on a
    grid of equally spaced parallel lines.  The length of each needle is 1/2
    that of the distance between the lines.  After dropping a large number
    of needles a count is made of the needles which cross a line.  Most
    needles do not touch or cross any line, but the ratio of the total
    number of needles dropped divided by the number of needles which cross
    a line approximates Pi.


12. PROPC - a symbolic logic program that calculates truth tables, analyzes
    tautologies, parses infix formulas and displays their Polish notation
    form, and generates Karnaugh maps from either tables or formulas.


13. RPNDEMO - a program which simulates how a calculator with RPN logic works.
    This program includes its own language and is similar in power to the
    HP-41 calculator.  Programs may be animated to show the internal workings
    of the machine.  Can also be used to teach assembly language concepts.


14. CALC - a reverse Polish logic calculator that operates on 5 data types.
    Included are real and complex numbers, fractions, binary integers and
    polynomials.  Special features include factoring integers and
    polynomials, analyzing repeating decimals and working with continued
    fractions.


15. LOAN - a finance program that handles the two standard cases of compound
    interest.  Uses the 5 standard financial variables n i PV PMT FV found
    on most financial calculators.  Can determine payment schedules for
    loans and annuities and can print amortization schedules for loans and
    interest earning schedules for lump sums and periodic payments.


16. FCARD - simple flash card type of program that can be used to memorize
    any simple series of facts, with one item per line of text.  Items can
    be presented in a random order with timing if desired.


17. THANOI - a game known as the Towers of Hanoi.  The game solution uses
    a recursive algorithm and the purpose of the program is to demonstrate
    the validity and simplicity of a recursive solution to a complex problem
    that would otherwise overwhelm a normal human being.


18. TRIANGLE - a simple program which solves triangle problems in which one
    is given 3 facts about a triangle and must solve for all the remaining
    parts.  Handles all 19 cases of triangle inputs and includes the Law of
    Cosines and the ambiguous case of the Law of Sines.  Can automatically
    determine when two valid triangle solutions exist.  Draws all triangle
    solutions to scale on a graphics screen and computes the perimeter and
    and the area in addition to finding and labeling all the sides and angles.


19. EXPMCON - a utility type of program that works with the above MATRIX
    program and the commercial scientific word processor called EXP.  This
    program converts MATRIX files from an ASCII format to the EXP format.


20. BMPLOT - a utility program that makes high resolution monochrome bitmap
    function plots, identical to the kinds of graphs made by the programs
    YFUNX, POLAR, PARAM, and POLPM.  The bitmaps may be read into other
    programs such as paint or drawing or desktop publishing programs which
    can be used to add labels and titles.  The monochrome bitmaps may be of
    any size or resolution so the output is compatible with virtually every
    printer and/or graphics environment.  The file formats supported include
    PCX, TIFF, and BMP.  The HP-GL/2 plotter language is an optional output
    to either a file or any HP-compatible plotter or PCL 5 LaserJet compatible
    printer.


21. XPRES - a program which computes integers with up to 20,000 digits per
    integer.  This RPN calculator is useful for computing exact values of
    factorials, permutations, combinations, and powers of integers.  For
    example, you can compute the exact value of numbers like 1000! or the
    exact value of 2 raised to the 5,000th power.  Integers may be saved to
    or read from ASCII text disk files.


22. TURING - a program which simulates the operation of a Turing Machine
    which is an abstract model of a primitive digital computer.  In fact,
    the model is fundamental to all digital (logical) computations.  Such a
    machine was conceived by the British mathematician Alan Turing in 1935,
    long before digital computers became established.  Turing also worked on
    machines to break codes used by the German Enigma spy machine in World
    War II.  Three sample demonstration programs are included.


For more information about any of these programs feel free to contact the
author.

   John Kennedy                   Voice Phone/Messages any time of day or
   Mathematics Department         night: (310) 450-5150  Extension 9721.
   Santa Monica College
   1900 Pico Blvd.                Internet E-Mail: jkennedy@smc.edu
   Santa Monica, CA  90405
   U.S.A.                         CompuServe User ID: 71514,751

