***************************************************************************
                   MARK'S MATH PLOTTER - V2.0 - HELP FILE
***************************************************************************
CONTENTS:
I.    NEW FEATURES IN VERSION 2.0
II.   SYSTEM AND USER REQUIREMENTS
III.  BACKGROUND
IV.   INSTRUCTIONS - GENERAL
V.    INSTRUCTIONS - SPECIFIC MODULES REACHED FROM THE MAIN MENU
VI.   EXAMPLES TO TRY
VII.  PRINTING GRAPHS AND SAVING GRAPHS AS IFF FILES
VIII. FILES INCLUDED ON THE ORIGINAL DISK
***************************************************************************



I.   NEW FEATURES IN VERSION 2.0

**** VERSION 2.0 IS MORE THAN  TWICE  AS  POWERFUL  AS ITS PREDECESSOR.  The
parser has been SIGNIFICANTLY EXPANDED so as to recognize 34, rather than 14
mathematical functions.  (SEE LIST IN SECTION IV, PART F)

**** Requesters now come filled in with  default values for the math novice.
Only the  function  has  to  be  entered  to  get  started.    In  addition,
REQUESTERS HAVE MEMORY, that is they always remember their last pass values.
This is handy when you only want to  change  one or two parameters at a time
as you draw.  Every pass now  takes  the  user  immediately  to the function
requester(s).

**** Up to 30 constants per expression are now allowed, rather than 24.

**** I also felt that  eventually  someone  would  want  to enter a function
longer than what would fit  on  one  line,  so  now  function requesters are
either 150 or 225 characters long depending on available screen space.

**** For those of you that know about parsing,  up to 75 tokens and 75 quads
per expression are  now  allowed,  ALLOWING  MORE  COMPLICATED  MATHEMATICAL
EXPRESSIONS.

**** Feeling that 2dgrapher would get  the  most use, I put a graphing speed
requester on 2dgrapher.  Use  it  to  speed  up  the  graphing.  Very little
accuracy will be sacrificed.

**** Some effort was also  put  into  placing  the  triad  on the graph more
accurately in 3dplotter and hidden3dplot.



II.  SYSTEM AND USER REQUIREMENTS

     System requirements include an Amiga with  one megabyte memory minimum.
Software developed under Workbench 1.3.   Compatible with Workbench 2.0 with
HiRes screen 640x200.  A math  coprocessor  or  accelerator chip is optional
and helpful, but not necessary.  Program will multi-task.  Use public domain
utility ScreenX to capture graphs as IFF files.
     User requirements: basic  knowledge  of  function  plotting  in two and
three dimensions; knowledge  of  the  built  in  functions,  and mathematics
beyond algebra.



III. BACKGROUND

     The idea for Mark's MathPlotter came about when I was teaching calculus
at a junior college.  Knowing  the  graphics  capabilities  of  the Amiga, I
decided to use my Amiga  as  an  electronic  chalkboard  to  draw  graphs of
functions that would have  been  nearly  impossible  to draw by hand.    The
computer could be used  in  conjunction  with  the  new calculators that can
graph, since most students can at least  afford the calculators.  Hopefully,
some students would see the advantage of using an Amiga during their college
years and go buy one.

     I looked to see what software was  available  for  the Amiga.  I bought
Doug's Math Aquarium, and examined  True  Basic's  packages, but they lacked
some of the features I  needed  for  teaching,  such  as  drawing  solids of
revolution, graphing polar functions,  etc,  and they were rather expensive.
So, I decided to put my M.A. in Mathematics  and my M.S. in Computer Science
to work and write my own program.  Modules have been continually added since
the original two, 2DGRAPHER and POLAR.  After many years of development (off
and on), I have arrived at the  current  eight modules.  A recursive descent
predictive parser for function parsing,  along with compilation of the code,
has reduced the rendering time considerably.

     Mark's MathPlotter is unique in many  respects.   It has the ability to
zoom in on graphs in the Cartesian  and  polar  planes, which can be used to
find points of intersection  to  6-7  place  accuracy.   It  can  be used to
generate wire framed solids  of  revolution,  a  feature for which one would
probably have to go to a CAD package  to  get.  In the 3d rendering you have
the choice of whether you  want  hidden  surface  removal  or not.  The user
interface is friendly,  with  help  available  for  all  input requester and
default values available  for  most  input  requesters.   Functions  use the
standard BASIC notation which is familiar to many.

     If you are a first time  user  please  read  over  the  instructions to
follow.



IV.  INSTRUCTIONS - GENERAL

SPECIAL NOTE TO CLI USERS:
     You MUST set the stack size to  allow  for  the  static arrays that are
used.  The command I use is 'STACK  32000'.   Do this BEFORE entering one of
'run mpintroV2.0' or 'run  mathplotterV2.0'  which get you into the program.
If you  go lower  than  '32000'  however,  or  you'll  probably  get a guru.
Workbench users will not have to worry  about this as the stack size is read
from the .info files.

ALL USERS:
     To start the program from the  workbench  double click on either of the
icons, 'MPIntroV2.0' or 'MathPlotterV2.0'.  To start it from the CLI type in
either 'run MPIntroV2.0' or 'run  MathPlotterV2.0'  AFTER  setting the stack
size as shown above.

     MPIntroV2.0 has some information screens before going to the main menu.
MathPlotterV2.0 takes you immediately  to  the main menu, from which you can
select one of ten items by clicking once  in the box of your choice with the
left mouse button or hit the key  indicated  in each selection.  There is an
addition help screen on 'What  are  valid  functions?'  which can be reached
from the main menu.

     Each module will begin with a screen  with  input  requesters.  You can
only put in input into a box when the box is  outlined in gold.  Upon module
startup, all requesters  are  filled  in  with  default  values,  except the
function requester. After entering the  function, if you decide some changes
are necessary, you can  randomly  make  changes  to  the various parameters.
After entering the function, you'll see two or more boxes at the bottom.  To
make changes to your input, click on the  left one ('CLICK HERE TO CLEAR AND
REDO INPUT') and then click on a requester  to change its value.  Change the
input, hit enter, and then  click  on  another  requester  if  you have more
changes.  You can continue to select  requesters  in this fashion until your
happy with all  the  values.   By  just  hitting  enter  after  selecting  a
requester, you can retain its previous  value.  When you're satisfied, click
on the right box at the bottom ('CLICK HERE TO CONTINUE AND GRAPH').

     Each requester, except for the  function  requester,  has an associated
default or last pass value.  To use it, just hit enter at the requester.  If
you are making  changes  to  the  data,  the  requesters  will  remember the
previous values it used.   ALL  REQUESTERS  IN  V2.0 NOW REMEMBER THEIR LAST
PASS  VALUES.   UPON  MODULE  START,  ALL  PARAMETERS  ARE  FILLED  IN  WITH
REASONABLE DEFAULTS.  HOWEVER, YOU MUST  AT LEAST ENTER A FUNCTION.  This is
a real time saver if you are redrawing the same graph over and over again.

     Each input requester has help which is  available by hitting the 'HELP'
key when the requester is outlined  in  gold.   A default value is available
for most requesters, except the function requesters, by just hitting 'ENTER'
in the requester.  The default value and well as any special restrictions on
the current input value can be  discovered  by hitting the 'HELP' key.  Each
input requester is expecting you to hit certain keys or it will beep at you.
For instance, there are requesters for positive integers which expect you to
only hit the keys 0-9.  For integers  in  general, you can begin with '-' or
0-9 in the first position, followed by  the keys 0-9.  Floating point (real)
values have the same valid keys as  integers,  with  the addition of the '.'
key.  Function requesters allow you to use all the keys, but if you input an
invalid function you'll  probably  get  an  error  message from the function
parser, and you'll have to start over.

     All requesters allow you to edit your input with the delete, backspace,
right and left arrow  keys,  before  hitting  return  to  move on.  Don't be
afraid to explore with different values.



V.   INSTRUCTIONS - SPECIFIC MODULES REACHED FROM THE MAIN MENU

NOTE: MAIN MENU CHOICES WILL BE INDICATED BESIDE THE MODULE NAME

A.   [1] 2DGRAPHER AND [2] POLAR

     These can be  used  for  drawing  functions  of  one  variable  in  the
rectangular or polar  coordinate  systems  respectively.   Both modules have
similar input requesters which are described below.

UNIT LENGTH:  Unit length refers to  the  number  of pixels for each unit in
the graph.  2DGRAPHER has one for x and y, POLAR has just one but also has a
requester for  increments  which  tells  it  the  number  of degrees between
samplings of the function.  Generally, the lower the number the smoother the
drawing (and slower). (integer, >0)

COORDINATES AT THE CENTER OF THE  SCREEN:   These help position the graph on
the screen.  Most of the time 0,0  will  be fine.  To explore other areas in
the plane, move the center.  A small gold circle indicates the center on the
graph.  In the polar version,  the  center  of  the screen is still given in
rectangular coordinates, not polar (i.e. (1,1) is r=sqr(2), theta=45 degrees
in polar coordinates). (reals)

FUNCTION REQUESTER:   Finally,  a  function  requester  expects  a  function
y=f(x), but don't type in the  'y='  part,  just  the  'f(x)' part.  If your
function is rejected you'll get an error message, and after hitting any key,
you'll be returned to the input screen.

     2dgrapher will also  prompt  you  for  a  graph  speed.   Just  use the
spacebar to select the value (1=slowest,  6=fastest), and then hit return to
start drawing.

     After the graph is drawn, 5 selections appear:

1)  ECHO COORDINATES - hit  1,  then  move  the  mouse  over the graph while
holding down the left button.  Coordinates  of where you're pointing will be
reflected on the screen.  This along with  the zoom feature can allow one to
find the intersection point of two  curves  to  within 6 places of accuracy.
Letting up on the mouse button quits this choice.

2)  ZOOM-IN - use to frame a  portion  of  the  graph to zoom in on.  Hit 2,
then move the mouse to the upper left corner of the area you want to zoom in
on, hold down the left mouse button  and  drag  the box over the graph until
you reach the lower right corner  of  the  area  you wish to zoom in on, and
then release.  It will recalculate the parameters and redraw that portion of
the graph.  The drag box in POLAR is kept in the shape of a square.

3)  ADD A GRAPH - (valid if only one  graph  has been drawn) hit 3, then you
will be prompted to type in a second function to graph.

4)  MAKE CHANGES - Lets you try again.  Erases the chalkboard.

5)  QUIT - Returns to main menu.


B.   [3] ROTATION(ONE) AND [4] ROTATION(TWO)

     These two modules are for drawing wire  frame representations of solids
of revolution (often done in calculus  or  engineering courses).  One or two
functions (depending on the module selected)  of one variable are bound to a
certain finite interval on the x axis.   Then both curves are revolved about
the x axis to generate a solid of revolution.

     The input requesters are:

UNIT LENGTH:  refers to the number of pixels  used per unit in each of the x
and y directions. (integer, >0)

COORDINATES AT THE CENTER OF THE SCREEN:  works the same as in 2dgrapher and
corresponds to  the  coordinates  in  2d  space  (the  xy  plane) before any
revolving is done. (real)

INCREMENT:  the number  of  degrees  the  curve(s)  is(are)  revolved before
it(they) is(are) drawn again. (integer, 0<?<90)

Y-ROTATION:  the number of  degrees  the  y  axis is rotated for viewing; if
this value is zero, the z axis is  coming  out towards the viewer, x axis is
to the right, and the y axis is  up;  a  positive  value rotates about the y
axis clockwise (as one is looking down the y axis towards the origin); hence
a value between 0 and 90 puts  the  viewer  in  the  first octant. (integer,
recommend -180<?<180)

DENSITY:  the number of pixels between  samplings of the function; a smaller
value yields a smoother,  more  accurate  drawing,  but is slower to render.
(integer, >0, recommend 2<?<5)

LOWER AND  UPPER  BOUNDS:   these  are  the  bounds  along  the  x axis that
indicates the interval of consideration. (real)

FUNCTION(S):  in ROTATION(ONE)  there  is  only  one function to revolve; in
ROTATION(TWO) there are two, a lower function (y=g(x)) and an upper function
(y=f(x)) where it is intended  that  g(x)<=f(x)  for  all  x in the interval
selected (this  is  not  a  strict  requirement,  experiment  and  see  what
happens).

     To try again, hit 'y', else hit any key to quit.


C.   [5] 3DPLOTTER AND [6] HIDDEN3DPLOT

     The input requesters are identical for  both of these modules.  In fact
both programs draw functions of two variables  (z=f(x,y)) over a rectangular
field in the xy plane, except that HIDDEN3DPLOT  has hidden surface removal.
Hence, 3DPLOTTER is  faster,  but  the  graphs  are  not  as realistic or as
pretty.  Their input requesters include:

LOWER X AND UPPER X:  these are the lower and upper bounds along the x axis.
(real, lower<upper)

LOWER Y AND UPPER Y:  these are the lower and upper bounds along the y axis.
(real, lower<upper)

SAMPLING RATE: this is a value  which  determines  the  sampling and drawing
density over the field; realistic drawings  need a value at least around 20;
the higher the  value,  the  slower  the  rendering,  but  a  better picture
results; the maximum is 50; the  default  32 is a good compromise. (integer,
0<?<50)

ANGLE OF PROJECTION:  number of degrees  the field will be 'twisted' to give
a 3d effect; turns out  to  be  the  angle  between  the  xy  plane  and the
'camera'. (integer, 0<?<90, recommend 20<?<50)

Z SCALAR FACTOR:  this is  a  factor  that  all  z  values are multiplied by
before drawing; if large z values are expected, make the value <.5; if small
z values are expected, try values >.5; you'll probably have to experiment to
get it just right;  if  its  too  big  funny  graphs  result.  (real,  >0.0,
recommend 0.0<?<.75, start small if you're unsure)

FUNCTION:  enter any valid function of two variables.

     Hit 'r' to retry, or any key to quit and return to the main menu.

NOTE:  For even better rendering of  functions  of two variables, use my new
release, NEW3D, or write me for a copy (address in MPIntroV2.0).


D.   [7] TABLE_XY

     This module generates a table of  function  values for functions of one
variable.  Initially, you'll be ask to click on one of two boxes to indicate
if you want one or two functions at once in the table.

     The first  three  requesters  are  for  X  MINIMUM,  X  MAXIMUM,  and X
INCREMENT.  These three requesters  all  depend on each other, so if you try
to edit one, you'll be placed in the  first  requester.   They all take real
values, and x minimum  should  be  less  than  x  maximum.   Also, if you're
tabulating two functions at once, you're only allowed 400 entries.  Based on
the three values entered,  it  will  check  to  see  if you've exceeded this
limit.  If so, you'll be warned and asked to reenter the values.

     Also, there will be one or two  function  requesters  depending on your
earlier selection.  Enter functions of one variable in each.  This module is
easy to use, so just follow the on screen  prompts.  One side comment, don't
hit the keys too rapidly as  you  page  through  the  table, as the keyboard
buffer will keep the keystrokes and  you  may  page past where you wanted to
look.  If you page past where  you  wanted  to  look,  you'll have to escape
('ESC') and restart (choose 'retry') the tabulation.


E.   [8] TABLE_XYZ

     This module is almost the same as  TABLE_XY,  but only one function can
be handled on screen at a time.  Again,  there are requesters for X MINIMUM,
X MAXIMUM, and X  INCREMENT,  along  with  a  similar  set  for Y MINIMUM, Y
MAXIMUM, and Y INCREMENT.   These  work  the  same as in TABLE_XY.  The only
difference is that there is no restriction on the number of entries that you
can have.

     Finally, there is a requester for a  function  of  two variables.  This
module is easy to use,  so  just  follow  the  on  screen prompts.  One side
comment, don't hit the keys too  rapidly  as  you page through the table, as
the keyboard buffer will keep the keystrokes and you may page past where you
wanted to look.  If you page past  where  you wanted to look, you'll have to
escape ('ESC') and restart the tabulation by hitting 'r' to retry.


F.   [9] or [HELP] HELP AND [Q] QUIT

     The help screen reached  here  tells  the  user  the  valid  constants,
variables,  operators,  and   mathematical  functions  supported  in  Mark's
MathPlotter.  Up to 30 constants per expression  are allowed.  Currently, 34
functions are supported in upper and lower case:

ABS     ACSCH   ASECH   ATANH   CSCH    FIX     LOG     SGN     TAN
ACOS    ACTN    ASIN    COS     CTN     FRAC    RND     SIN     TANH
ACOSH   ACTNH   ASINH   COSH    CTNH    INT     SEC     SINH
ACSC    ASEC    ATAN    CSC     EXP     LN      SECH    SQR


     To exit Mark's MathPlotter, choose [Q] to quit.



VI.  EXAMPLES TO TRY

For those unfamiliar with this software  and/or mathematical functions, here
are some examples to get you  started.   The  values are listed in the order
they appear on the screen starting in the upper left.  Enter the function(s)
first, then go back and change any parameters if needed.

2DGRAPHER:
example) 20, 20, 0, 0, x^3-x; Hit return  to use the default graphing speed.
After this first function is graphed, choose 'add a graph' and graph sin(x);
with both graphs on the screen, try  to  find  the intersection point in the
first quadrant using the zoom-in and echo coordinates features.

POLAR:
example) 40, 45, 0, 0,  sin(2*x);  then  add  the graph sin(3*x); retry with
sin(4*x) and sin(5*x); these graphs  are  known as roses; can you deduct how
many petals are in a rose of the form sin(k*x), based on different values of
k? (hint: consider odd and even values of k separately)

ROTATION(ONE):
example) use all defaults except make unit lengths 20, 20.  Use the function
(f(x)=) cos(x)+1.
example) 20, 20, 0, 0, 45, 30, 3, 0, 6.28,  (f(x)=) sin(x)+1.5 (draws a vase
like object).
example) 20, 20, 0, 0, 30, 45, 3, -2, 2, (f(x)=) x^2+1

ROTATION(TWO):
example) use all defaults.  Let (g(x)=) sqr(x), (f(x)=) 2*sqr(x)
example) use all defaults except change unit lengths to 15, 15 and make the 
upper bound 6.0.  Use the functions (g(x)=) cos(x), (f(x)=) sqr(x)+1.
example) 20, 20, 0, 0, 45, 30, 3, -2, 2, (g(x)=) 1, (f(x)=) 5-x^2
example) 25, 25, 0, 0, 60, 45, 3, -1, 1, (g(x)=) x^2+1, (f(x)=) 3-x^2

3DPLOTTER AND HIDDEN3DPLOT:
example) -3, 3, -3, 3, 40, 30, .25, sin(x^2+y^2) (draws a rippled hat).
example) -3, 3, -3, 3, 35, 35, .2, x^2-y^2  (draws a saddle)

TABLE_XY AND TABLE_XYZ:
Experiment with the above functions.



VII. PRINTING GRAPHS AND SAVING GRAPHS AS IFF FILES

     To print graphs, use the Graphidump  utility  on Workbench, or save the
graph as an IFF file (as described below),  and print out with your favorite
utility.  For those with a standard B&W dot matrix, I recommend setting your
printer preferences  (under  Graphics  1  for  those  with Workbench 1.3) to
Image: negative, Shade: black &  white,  and Threshold: 14 for graphs with a
black background, 11 for graphs with  a  dark green background.  Choose SAVE
or USE for these  settings.   Then  position  the  Graphidump  icon so it is
visible and ready to use  on  the  Workbench.   Now,  draw  the graph in the
program.  Use the depth arrangement  gadgets  in the upper right to get back
to the Workbench screen so as to double  click Graphidump.  I had to use the
Left Amiga N and M to get back  and  forth  on  the  screens with the hires,
interlace, black background graphs.   I  haven't  figured out why as of yet,
but it gets the job done.   This  technique  gave  nice  printouts on my dot
matrix.
     To save graphs as IFF files, I use  the  public  domain utility ScreenX
found on many BBS.  I open up ScreenX  on  the Workbench, draw my graph, and
then return to my Workbench as described  above to open up ScreenX.  The two
main tasks this utility performs is saving screens as IFF files and printing 
screens.  However, I could  never  seem  to  get  ScreenX to read my printer
preferences as I had set them, so I  decided  to use ScreenX just for saving
the graphs as IFF files.   I'll  use  Graphidump  for  the  printouts.  Once
saved, these graphs can be used in any slide show or paint program.



VIII. FILES INCLUDED ON THE ORIGINAL DISK

Files on the original Mark's MathPlotterV2.0 disk:

mathplotterV2.0     mathplotterV2.0.info
mpintroV2.0         mpintroV2.0.info
bas.rl              mathplotter.hlp     readme
readme.info         2dgrapher.run       polar.run
rotation_one.run    rotation_two.run    3dplotter.run
hidden3dplot.run    table_xy.run        table_xyz.run


                        <<END OF USER HELP MANUAL>>