home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Resource Library: Graphics
/
graphics-16000.iso
/
msdos
/
fractal
/
iterat31
/
iterate!.txt
< prev
next >
Wrap
Text File
|
1993-12-29
|
74KB
|
1,629 lines
╔════════════════════════╗
║ ║
║ ║
║ Iterate! ║
║ ║
║ Version 3.11 ║
║ ║
║ ║
║ ║
╟────────────────────────╢
║ ║
║ ║
║ Copyright 1993 ║
║ ║
║ ║
║ by ║
║ Brent Hugh ║
║ ║
║ ║
╚════════════════════════╝
INSTRUCTION MANUAL
══════════════════
CONTENTS
════════════════════════════════════════════════════════════════════════════════
Quick Start
Program Distribution
Files Included
Legal Disclaimers
How the Program Works
Iteration
Fractals
Chaos
Parameters
Program Commands
Graphics Screen Commands
Basic Commands
Special Commands for Julia/Mandelbrot Sets
Dos Commands
Iteration Stack Commands
User Function Commands
Edit Menu Commands
The User Function
The User Function File
The Name
The Defaults
The Function
Error Messages
Video Adapters
Mouse
Printing
Runtime Error Messages
Heap Overflow Errors
"Floating Point Overflow" and "Division by Zero" Errors
Miscellaneous Program Info
Upcoming Additions
Bibliography
QUICK START
════════════════════════════════════════════════════════════════════════════════
At the DOS Prompt, type "Iterate!" to start the program.
You are presented with an introductory screen with some instructions. Press
any key to move on to the graphics screen. At the graphics screen you can use
the mouse to move around and iterate points. Press the left mouse button to
iterate a point. Press the middle mouse button to switch between the graphics
screen and the command screen, which lists all available commands. (For you
unlucky folks with only two mouse buttons, pressing both buttons together is
the same as pressing the middle button.)
If you don't have a mouse, never fear! Iterate! can accommodate you. Just use
these keys to move around and iterate points:
Arrows move
Space iterate a point
M move the cursor to the next iteration, allowing
you to trace the iterations of a point
Escape switch between the graphics screen and the
command screen (which lists all available options)
Q quit
These keys change distance you move when you use the arrow keys:
CapsLock switch between medium and giant steps
Shift make baby steps
Note: <CapsLock> is a toggle, but <Shift> must be held down as you're pushing
the arrow for it to have an effect.
<Escape> (or middle mouse button, or left and right mouse buttons together)
switches between the graphics screen and the command screen, which lists all
available commands. However, all commands are available on the graphics screen
(if you can just remember which button to push).
<F1> shows a help screen.
PROGRAM DISTRIBUTION
════════════════════════════════════════════════════════════════════════════════
This program is SHAREWARE. Please pass it along to friends, neighbors,
relatives, and fellow mathematics buffs. If you find it useful, educational,
entertaining or addictive (as I have), please become a registered user by
sending $15 to:
Brent Hugh
986 Raymond Road
Fruit Heights, UT 84037
The Many Glorious Benefits of Registering
─────────────────────────────────────────
Becoming a registered user will help me justify work on similar products in the
future--and help you feel less guilty.
In addition (as though you really need anything more), registered users will
receive a disk with the latest version of Iterate!, a version of Iterate!
compiled for 286 and better computers (runs 10-20% faster), and several other
programs that illustrate chaos and fractals--including my latest program that
makes 3-D fractals.
Also included on the disk will be a Mandelbrot-Julia Set generating program--
the program that generated the file "Mandelbr.gph" that is included with
Iterate!. Iterate! and this Mandelbrot-Julia generator work hand-in-glove,
together making a powerful tool for investigating the Mandelbrot Set and its
associated Julia Sets. Using the Mandelbrot-Julia generator, you can create a
graph of the Mandelbrot Set. You can then load this graph into Iterate! and
enter Julia Set parameters directly from the Mandelbrot Set. You will
immediately see the correlation between a point on the Mandelbrot Set and its
associated Julia Set. (See "Function.txt" for more info on this subject.)
If you are interested in using multiple copies of Iterate!--in a school
setting, for instance--please write to me about special rates. I'm sure we
can work something out that will be agreeable to us both.
When you register, please include your name and address and specify 3 1/2 or
5 1/4 inch disks. Don't forget to include any good user function files you
have come up with--the best ones will be distributed with future versions of
Iterate!.
Might I mention that this is a REAL DEAL! The shareware distributor places
charge around $15 just to send you a program like this and then you're supposed
to register ON TOP of that.
FILES INCLUDED
════════════════════════════════════════════════════════════════════════════════
These files are distributed with Iterate! If you share the program with someone
else, please include ALL of these files. If your copy of Iterate! doesn't
include all of these files, please write me for a complete copy (include a
blank disk and self-addressed, stamped disk mailer if you're not registering).
Iterate!.exe The program file
* .frm Sample user functions. There will be several of these.
Mandelbr.gph A graph of Mandelbrot Set that works with Iterate!
(see Function.Txt for more details; see also Note below)
KBRepeat.exe Utility to change the keyboard repeat rate
WhatsNew.txt What's new in this version of Iterate!
HowTo .txt How to do common things in Iterate!
Function.txt A short discussion of the functions in Iterate! with some
example parameters and other things you can try
Jargon .txt An explanation of some of the jargon of Iteration Theory
QuickCmd.txt Quick one page synopsis of Iterate!'s commands
Readme .txt An overview of Iterate!
Iterate!.txt This file
Iterate! makes files of these sorts:
*.gph
*.inf
*.ini
If, after a while, you find a bunch of these files scattered around your disk,
Iterate! is responsible.
Note: "Mandelbr.gph" is drawn in VGA mode 1 (which is the same as EGA mode; this
is the default startup graphics mode for Iterate! if you have a VGA or EGA
adapter). If you are unable to run Iterate! in VGA1 mode or EGA mode, you
won't be able to use "Mandelbr.gph". Sorry. If you become a registered user
of Iterate!, you will receive a Mandelbrot-Julia Generator that will allow you
to draw Mandelbrot and Julia Sets in any graphics mode you want.
LEGAL DISCLAIMERS
════════════════════════════════════════════════════════════════════════════════
This is the section of the help document where the programmer/programmers
disclaim(s) any responsibility for anything and everything that may or may not
happen as a result of using and/or not using his/her/their program and/or
documentation for any purpose whatsoever.
Please consider me so disclaimed. If you hurt, kill, or maim anything or
anybody by using this program, it's not my fault--especially if you haven't paid
your registration fee.
You can't sell this program to anyone (you can charge small distribution/copying
fees). You can't include this program with other programs that you are selling.
In short, all the profits from this program--meager as they may be--belong to
me, not you. (Sorry--I'm sure you'll get over it soon.)
I retain all rights to this program. It is not in the public domain. You
cannot alter it and then distribute the altered version. (You're welcome to
alter it for your own amusement if you'd like.)
(Have you ever noticed that all manuals put the boring legal stuff at the
beginning so you have to plow through it all before you get to the good stuff?
Well, everybody else does it, so I had to, too. Congratulations on making it
this far--and now here's the good stuff . . .)
HOW THE PROGRAM WORKS
════════════════════════════════════════════════════════════════════════════════
Iteration
─────────
Iterate! is based on the mathematical idea of iteration. Iteration works like
this: Imagine you have a calculator. Punch a number into the calculator. Then
pick a function key on the calculator, like 'sin' or 'x²'. Repeatedly push this
function key, and see what happens.
Here are some of the things that can happen when you iterate a function on your
calculator (in parentheses are the function that gives this result and the
number to start with):
* The number gets closer and closer to some number (cos, any number)
* The number alternates between two or more numbers (1/x, any number but 1
or 0)
* The number gets larger and larger (x², any number larger than 1)
* The number jumps around in a seemingly random fashion (1-2x², most numbers
between -1 and 1)
Just playing with your calculator like this can provide hours of amusement,
especially if you have a programmable calculator so you can do some of the more
interesting functions. See the bibliography for some books that provide some
interesting functions and results.
This iteration process that you can do with your calculator is exactly what this
program does, except in the program we use "a point on the screen" and "a
function programmed into the computer" instead of "a number" and "a function key
on your calculator."
Here are some of the things that can happen when you iterate on the computer:
* The point spirals in towards a certain point (an attracting fixed
point)
* The point does a certain number of points and then repeats. This is
called a periodic point. The number of points before repetition can be 2,
20, 200, 2000, 20000, or anything in between.
* The point traces out a pattern. The pattern can be anything from
simple circles or ovals to complex fractals.
* The point jumps around in a seemingly random fashion (chaos).
* The point jumps around in a seemingly random fashion, but sticks within
a certain area. This area can be simple or complex; often it is a
fractal.
If you experiment with Iterate! a little, you will soon see all of these things
(and many more) happening.
Of these things, fractals, chaos, and periodic points are among the more
fascinating. Here is a little explanation about them.
Fractals
────────
The study of fractals is one of the most fascinating and visually appealing
areas of mathematics.
Fractals are shapes that are selfsame under magnification--if you look at a
small part of a fractal, it looks just like the whole thing. To put it another
way, a fractal has the same shape over many different sizes. (In mathematically
generated fractals, the shape is usually repeated over infinitely many different
sizes. However, in the fractals found in nature, the shape is typically
repeated between 5 and 20 times.)
A good example of a fractal is a tree. A branch of the tree has the same shape
as the whole tree. A smaller branch of the tree has the same shape as the
larger branch, as well as the same shape as the whole tree. So a small part of
the shape looks like the whole thing.
Many fractals are found in nature. Some examples are cauliflower, broccoli,
mountains, river systems, air passages in lungs, the growth pattern of certain
cancer cells, cracks in rocks, clouds, and the pattern of stars in the sky.
Nearly all of the functions in Iterate! will produce fractal patterns. Here is
one particularly obvious one: Choose Function C with the default window and
parameters. Set the number of iterations to 1000. If you trace out a few
points, you will see a large circle surrounded by five small circles. If you
try some points near the five small circles, you will find that each of the
five small circles is surrounded by smaller circles. Zooming in on these
smaller circles would reveal even smaller circles surrounding them. Further
zooming reveals smaller and smaller circles, always in this same pattern of
a larger circle surrounded by smaller circles.
It looks sort of like this (if you can imagine circles instead of squares, and
3, 4, 5, or 6 circles surrounding, instead of just four each time):
O O O O
┌─┐ ┌─┐
└─┘ └─┘
O O O O
┌────┐
│ │
└────┘
O O O O
┌─┐ ┌─┐
└─┘ └─┘
O O O O
Oddly enough, this same type of fractal pattern is shown by several of the
functions programmed into Iterate!--even by functions that algebraically aren't
at all close to each other.
Chaos
─────
Chaos is--well, chaotic. In a chaotic function, the point jumps around in a
completely unpredictable way. Mathematicians find chaos fascinating because
these very unpredictable results come from rather simple, predictable-looking
functions.
Mathematicians and scientists study mathematical chaos in their search to
understand chaotic behavior in nature: weather patterns, transition states of
materials, the orbits of comets, mixing of materials, population growth, and
many others.
To see an example of chaos, choose Function I with the default window and
parameters.
Periodic Points
───────────────
Periodic points are the antithesis of chaos--they are regular, predictible and
orderly.
Periodic points are points that repeat the same path over and over. The
number of iterations before the point returns to its original position is
called its "period". For instance, a period 5 point takes 5 iterations to
return to its original position; a period 43 point takes 43 iterations to
return to its original position. A period 1 point (or fixed point) doesn't go
anywhere--it just stays in its original position without ever moving.
Periodic points come in two main varieties: attracting and repelling.
An attracting periodic point pulls nearby points closer and closer to it. A
attracting fixed point, for instance, sucks in all nearby points like a giant
black hole. If you iterate a point near it, you might see a spiral, circling
ever closer to the fixed point.
A repelling periodic point pushes nearby points away from itself. If you
iterate a point near a repelling fixed point you might see the point
spiralling outwards.
A point can be either strongly or slightly attracting; the same goes for
repelling. Usually, the points that are only slightly attracting or repelling
are most interesting visually.
Believe it or not, a chaotic function has periodic points as well. However,
they are all repelling periodic points. This is what makes the function
chaotic.
A good way to investigate periodic points is to use the <M> command to trace
out the path of a point. This makes it much easier to follow the orbit of the
point.
(The path of a point under iteration is called its "orbit" by the way. A
mathematician would say that Iterate! plots the orbits of points under
iteration.)
Using Iterate!, I have found attracting periodic points of period up to 125.
It is possible (with the right function and parameters) to find periodic
points of any period--1000, 1000000, or even larger.
Here is a good example: Choose Function E with the default windows and
parameters. Choose <J> to draw the Julia Set associated with this function.
Now iterate a few points using <Space>. If you iterate a point inside the
Julia Set, you will see three dark dots appear. This is a period 3 attracting
point. Now press <M> repeatedly to trace out the orbit of a point in the
Julia Set. You will see that for the first few iterations, the point jumps
around the set. After a while, it settles down and moves closer and closer to
the three attracting points.
Approximately in the middle of the three attracting points is a repelling
fixed point. If you put the cursor near this repelling point and press <M>,
you will see that the point spirals outward. After it spirals out a ways, it
may be attracted to the period 3 point, or it may leave the Julia Set
altogether.
(See "Function.Txt" for more info about Function E and Julia Sets.)
Parameters
──────────
When mathematicians study iteration, one of the main things they study is the
effect of changing the parameters of the function.
Let us take a simple function with a single parameter: 1-ax². In this function
'a' is the parameter. What you will discover, if you try this function with
different values for 'a', is that changing the value of 'a' slightly can change
the behavior of the function dramatically. Some values of 'a' make the function
very nice and well-behaved (one attracting fixed point); others make it wildly
chaotic (an infinite number of repelling periodic points); yet others are
somewhere in between (some attracting periodic points and some some repelling
periodic points).
One question mathematicians ask is: "At which value of 'a' does the function
change from well-behavedness to chaos?" This value is known as a "bifurcation
point."
Using Iterate!, you can try changing parameters and observing the results of
these changes. Here is a good example:
Choose Function A. First choose the default window and parameters, and iterate
a few points to see what happens.
Then, choose Function A again, but this time enter a=3 and b=3. (Leave the
other parameters as they are. You might want to choose a larger graphics window
so you can better see what's going on.) Again, iterate a few points. You will
be amazed at the difference this small change makes.
You can try different values for 'a' and 'b' between 0 and 3 to see how the
graph gradually changes from order to disorder. If you're lucky, you might
discover a "bifurcation point"--the parameter value where the large ovals split
to become two smaller ovals.
For more information on iteration, fractals, chaos, and bifurcation points,
consult the books listed in the bibliography.
PROGRAM COMMANDS
═══════════════════════════════════════════════════════════════════════════════
Iterate! is designed to be pretty much self-explanatory, once you know what it
is supposed to do. Just in case it isn't, though, here is a list of all the
commands that are available.
General Notes
─────────────
Upper or lower case works the same on all commands.
Pressing <escape> almost anywhere will abort the command and return you to the
command screen or graphics screen.
<F1> shows a help screen, with a brief summary of relevant commands.
Graphics Screen Commands
────────────────────────
<Space> or <Left Mouse Button>. Iterates the point currently at the crosshairs.
Note: An iteration can be interrupted by pressing any key besides <Space> or an
arrow, or any mouse button besides <Left Mouse Button>.
<M>. Moves the cursor to the next iteration of the point. By repeatedly
pressing <M>, you can slowly trace out the successive iterations of a point.
This is great for finding periodic points and for any time you want to get a
more detailed idea of what a point is doing.
<M> works better if you hide the graphics screen help line (use the <H>
command).
A fun thing to try with the <M> command is to move the mouse as you're
pressing and holding <M>. This works especially well if you're near an
attracting point. The mouse move is a "perturbation" of the the point; this
will test how stable the attracting point is. If the mouse move drives the
cursor away from the attracting point, the attracting point is quite unstable.
If the mouse move drives the cursor momentarily away from the attracting
point, but it soon comes back, then the attracting point is very stable.
Note: <M> works much better if the typematic rate on your keyboard is set to a
fast value so that the keys on your keyboard repeat quickly. Iterate! can do
this for you automatically; see the <G> command for more details.
<H>. Shows/hides the help line at the top of the graphics screen.
<W> or <Right Mouse Button>. Zooms in on a certain area. Pressing <Ctrl> while
doing this zooms out instead. See the <W> command below for more information.
<Arrow keys>. The arrow keys move you around the graphics screen.
<CapsLock>. Switches between medium and large steps when you press the arrow
keys. This key is a toggle--pushing it once will change to large steps, pushing
again will change back to medium steps.
<Shift>. When pushed with an arrow key, moves the smallest step possible on
your graphics screen.
<Esc> or <Middle Mouse Button>. Switches between the graphics screen and the
command screen. (Remember that on a two button mouse, pressing both buttons is
the same as pressing the middle button.)
Basic Commands
──────────────
<Q>. Quits the program.
<F1>. <F1> shows a help screen (the same thing that is in QuickCmd.txt).
<D>. <D> dumps vital information about your current function and graphics
window to the printer. This is useful if you have printed a graph (see
"Printing").
<N>. Pressing <N> erases the graphics screen so you can start a new graph
(asking you first if you really want to). If you have points on the iteration
stack, <N> will ask you if you want to delete them or keep them.
<T>. Sets the number of iterations to be performed. This number is used
whether the point is iterated immediately (using <space>) or automatically as
part of the iteration stack (using <I>). The maximum number of iterations
allowed is 2147483647 (2^31-1, just in case you're wondering).
<W>. Sets the graphics window. This is the area that is shown on the graphics
screen. 'W' works differently depending on whether you are in the graphics
screen or the command screen.
* On the Graphics Screen, <W> works like this: Position the crosshair at one
corner of the area you would like to view, and press <W>. The cursor will
change from a cross to a rectangle. Move the corner of the rectangle (by using
the mouse or arrow keys) until it encloses the area you want to view.
Press <W> again to complete the window.
If you press <Ctrl-W> instead of <W>, you will zoom out instead of zooming in.
That its, in the new graphics window, the present graphics window will look
like area you specified.
Remember that pressing <Right Mouse Button> on the graphics screen is the same
as pressing <W>.
Note 1: You will notice that Iterate! sometimes rotates the screen 90 degrees--
that is, the y axis becomes the horizontal axis. Iterate! automatically does
this to accommodate the area you entered--depending on whether it's a short, fat
rectangle, or a tall, thin one.
Note 2: Iterate! always expands the windows coordinates to make them fit the
entire graphics screen with the correct aspect ratio. So you may see a little
more than you specified (but you will never see less).
* At the Command Screen, pressing 'W' lets you specify the window coordinates
manually. Iterate! will ask you for the least and greatest x coordinates, and
the least and greatest y coordinates of the area you want to view. Then it will
ask you if you want to make the x axis the horizontal coordinate (the usual
way), or the y axis (rotated 90 degrees counter-clockwise from usual).
Iterate! will then clear the graphics screen and send you on your way.
If you leave all values unchanged, Iterate! will not clear the graphics screen
or change anything. This provides a handy way to view the values of the current
graphics window.
Note: Iterate! will expand the window coordinates you enter to make them
fit the entire graphics screen.
<F>. <F> allows you to choose the function Iterate! will use, and specify the
parameters for that function.
The functions used by Iterate! take a point on the graphics screen to another
point on the screen. In other words, a coordinate (x,y) is taken to another
coordinate (x',y'). Mathematicians would say that this is a function R² -> R².
The point of this is that our functions must have two parts: one part to tell
where the x coordinate goes to, and one part to tell where the y coordinate goes
to.
When you push <F>, you will see a list of the available functions. A typical
function will look like this:
x -> cos(axy) + bx y -> sin(cx/y + mu) + dy (my favorite function)
This means that the x coordinate goes to 'cos(axy) + bx' and the y coordinate
goes to 'sin(cx/y) + dy'. The a, b, c, d, and mu are parameters; you will be
able to enter values for these later.
Some of the functions have little comments--"my favorite function" or whatever.
If you want to find out more about the functions than these little comments
tell you, then read "Functions.Txt".
The last function (Function U) is a user function. This is where you can try
out your own functions. See "THE USER FUNCTION" in this document for more
details.
After you enter the function, you enter the parameters.
Iterate! will ask you if you want to use the default window and parameters for
this function. If you haven't tried the function before, using the default
window and parameters is a good idea. The default window and parameters will
focus you on an interesting area of the plane with some good parameters. Later,
you can experiment by changing these parameters slightly (or greatly).
Many functions only use one or two of the parameters. In this case, it doesn't
matter what you enter for the rest of the parameters. I suggest leaving them
unchanged. HOWEVER, you can enter any value you want in these unused parameters.
This is your big chance to enter the most obnoxious number you can think of
without the slightest chance of blowing up your CPU. So go to. Be anarchic.
Enjoy yourself for once.
Mu is typically used as an angle parameter. If this is the case, it is entered
in degrees. (Note: In the User Function, mu is figured in radians, not degrees.
Sorry.)
<G>. <G> allows you to adjust various program parameters. The parameters
you can adjust are:
* Aspect ratio. The aspect ratio is the horizontal size of your CRT (in inches)
divided by the vertical size of your CRT (again in inches). Unless your monitor
is really weird, the aspect ratio should be 1.333333. If the aspect ratio is
set wrong, thing will be squashed or stretched on the screen. For instance,
circles will be squashed or stretched into ellipses.
The most common reason you will want to adjust the aspect ratio is to compensate
for your printer--often a printed image will have a different aspect ratio than
it did on the CRT. Just measure the horizontal and vertical size of a printed
image, figure the aspect ratio (horizontal size divided by vertical size), and
enter it here. Then your printouts will look nicer.
Note: Changing the aspect ratio won't change anything until you enter a new
graphics window (see <W>). The aspect ratio works by adjusting the boundaries
of the graphics window so that they have the correct proportions. Iterate!
won't make the necessary adjustments until you enter some new window
coordinates.
* Graphics Color. This determines the color that will be displayed on the
graphics screen. As a rule, color #15 will produce white.
* Text Foreground Color for menus. A number between 0 and 15. White is 7,
black is 0, bright white is 15.
* Text Background Color for menus. Ditto.
Note: If you have a monochrome text adapter (Hercules), the text color
settings will have no effect.
* Default Value for "Save Graphics Screen". This determines whether a "Y" or
"N" comes up whenever the program asks "Save Graphics Screen (Y/N)". If
you never want to save your graphics screens, change this to "N" and save
yourself a lot of headaches. If you always spend three hours making a spiffy
graph and then forget to save it, change this to "Y" and save yourself a lot
of headaches.
* The text editor to use when editing User Function Files. This changes the text
editor that you use when you press <E> to edit the User Function. You can use
your own text editor by entering its name here, or use Iterate!'s built in text
editor by leaving this entry blank.
You must enter the full path and filename of the text editor you want to use,
for example "c:\dos\util\edit.exe". If the path is not complete, or the full
filename isn't used (including the extension), Iterate! won't be able to find
the file. In this case you will get an error when you use the <E> command to
edit the User Function File.
You will need a pretty good chunk of memory free to use this option--about
425K plus the amount needed by your text editor. For this reason, your favorite
gigantic text editor probably won't work here. For instance, "Edit.com" that
comes with DOS probably won't work--it's way too huge. I use "Ted.com", a
little shareware text editor, and it works great. If your text editor is too
big, you can probably find a more compact one on a local BBS (or just put up
with Iterate!'s built in editor).
Make sure the editor you use here returns just plain old DOS text--otherwise
Iterate! will get real confused. Don't try to use WordPerfect or something like
that.
* Set keyboard repeat rate on startup. If this option is marked "Y", Iterate!
will automatically set the repeat rate to its fastest possible value at
startup. This dramatically speeds up keyboard response when using the arrow
keys to move or the <M> command to trace an iteration. If this option is
marked "N" then the keyboard repeat rate is left unchanged.
(Note that the "KBrepeat.exe" utility included with Iterate! allows you to
change to keyboard repeat rate from the DOS command line--either to recover
from what Iterate! has done to you, or just to change it however you want.
Unfortunately, it is impossible to detect the setting of the keyboard repeat
rate, so Iterate! can't return the repeat rate to the state it was before it
started. If you don't like the repeat rate Iterate! leaves you with--the
fastest possible setting--you can use KBRepeat to change it the way you want.)
Iterate! saves the all these parameters and defaults (as well as the default
User Function Filename and the default color for drawing Julia Sets) in a file
named "Iterate!.ini". "Iterate!.ini" is located in the directory that
Iterate! is in.
If you get the colors too goofed up (you can't read text screens or
see the graphics screen, for instance), just delete "Iterate!.ini".
Everything will return to its default value. Any time, in fact, the program
is acting a little strange, it might be a good idea to delete the
"Iterate!.ini" file. Doing this restores all these settings to their
"factory pre-sets".
Special Commands for Julia/Mandelbrot Sets
──────────────────────────────────────────
These two commands are designed to be used with Function E, the function that
draws Julia Sets. Using these commands along with Iterate!'s usual commands
and the file "Mandelbr.gph" gives a powerful method of investigating the
properties of Julia Sets. See "Function.txt" under Function E for more
details.
<J>. The <J> command only works if Function E is selected as the current
function. <J> draws the Julia Set associated with Function E and the current
parameters.
Pressing <J> is exactly the same as selecting Function F, retaining graphics
window and parameters, iterating a point 10000 times, and then changing back
to Function E. Using <J>, however, is much easier than doing all that. You
will want to use <J> whenever you are working with Function E. See
"Function.Txt" for more information.
<Z>. Zips the coordinates of the graphics screen into the parameters. The x
value of the screen coordinate becomes parameter 'a' and the y value becomes
parameter 'b'. You are presented with a menu with these new values, and have
the opportunity to change any of the parameters or window coordinates before
accepting the new values.
<Z> is designed to be used with Function E and the file "Mandelbr.gph".
Here's how you should use it.
1. Use the <F> command and choose Function E.
2. Use the <R> command and load "Mandelbr.gph".
3. Move the cursor to any spot in or near the Mandelbrot Set.
4. Press <Z> to load these coordinates as the parameters.
5. Press <J> to draw the Julia Set associated with these parameters.
6. Use <Space> and <M> to investigate the properties of Function E with
these parameters.
DOS Commands
────────────
<S>. <S> saves the current graphics screen. A saved picture take between
16,000 bytes (CGA mode) and 170,000 bytes (VGA2 mode) of disk space.
Iterate! asks for a file name WITHOUT the extension. The reason for this is that
when you save your graph, Iterate! actually makes two files, one with the
extension ".gph" and the other with the extension ".inf". The ".gph" file is
the actual graphics screen, while the ".inf" file contains information about the
graph (which function is used, parameters, graphics window, iteration stack,
etc.).
If you're short on disk space, you might try running the program in CGA or
Hercules Graphics mode (if your graphics card is compatible with one of these),
because saving a graph created in these modes takes much less disk space than
one created in EGA or VGA modes. See "GRAPHICS MODES" below for more details.
Iterate! saves the screen in its own proprietary graphics format (don't tell
anybody, but actually it's nothing but a massive memory dump). So it isn't
compatible with any other graphics file formats. Sorry. If you really want to
save your beautiful screens in a graphic format such as .bmp or .gif, there are
screen grabber utilities around that will do it. Or if you have a 386 or better
and run Windows in advanced mode, you can run Iterate! in a window, hit <Alt-
PrintScreen> to copy the window to the clipboard, and then paste the window into
PaintBrush (Ctrl-V). There you can print it or save it to your heart's delight.
<R>. <R> retrieves a graphics screen that you have previously saved.
One warning: don't try to retrieve a graphics screen that you saved in a
different graphics mode. Iterate! isn't able to change graphics modes in mid-
stream, and take my word for it--your graph will look pretty darn funny. If you
want to retrieve such a graphics screen, you will have to re-start Iterate! in
the graphics mode you saved it in. (See the section below on "Graphics Modes"
for more information on how to do this.)
<X>. <X> lists the files in the directory you specify.
<O>. <O> shells out to the operating system. Once you have shelled out, type
"exit" to return to Iterate!.
This command is very useful. You can leave the program for a moment to do some
housekeeping--copy or erase files, for instance--and then return to Iterate!
with everything still intact.
Iterate! won't be able to shell to DOS if there is insufficient memory. If you
have about 300K-350K free when you start Iterate!, you should be safe.
Iteration Stack Commands
────────────────────────
Iterate! provides a stack of iteration points that can be iterated in sequence,
automatically. Several commands allow you to enter points on the stack and then
iterate them.
The idea behind the iteration stack is this: Suppose you are investigating a
function, and you are looking at a rather high magnification so that it takes
200000 iterations of each point just to get a clear picture on your screen.
If you had to enter each point individually and wait for 200000 iterations, it
would take forever. But, using the iteration stack, you can enter 40 points
all at once, and then set them to iterating automatically. When you wake up
the next morning, your spiffy picture will be all done.
Also, you can interrupt the automatic iteration process (just press any key when
it is iterating and it will stop). If you then press <I> again, the automatic
iteration will resume where it left off.
Another advantage of the iteration stack is that you can save an interrupted
iteration. Iterate! saves information about the iteration stack in the ".inf"
file. So you can interrupt an automatic iteration, and save it, then later
retrieve it and continue where you left off.
Yet another advantage (wow! isn't this a really great feature?) is that Iterate!
keeps track of the endpoint of each iteration point on the stack (i.e., where
the point ended up after it was iterated). You can add the endpoints back
onto the iteration stack and continue iterating them.
So suppose you've iterated 40 points on the iteration stack 20000 times each.
You decide this isn't enough--you need to iterate them another 20000 times.
This is easy--you just add the endpoints onto the stack (using the <C> command),
and iterate them another 20000 times.
Here are the iteration stack commands:
<A>. <A> automatically adds points to the iteration stack. The points added by
<A> are in a rectangular array, evenly spaced around the current graphics
window. When you press <A>, Iterate! will ask you how many points you want in
the X direction, and how many in the Y direction. If you enter the defaults of
'7' and '6', this will enter 42 points, in a rectangular array on the screen.
<P>. <P> allows you to individually enter points to the iteration stack. <P>
works differently, depending on whether you're on the graphics screen or the
command screen when you press it.
Pressing <P> on the graphics screen enters the point at the crosshairs to the
iteration stack.
Pressing <P> at the command screen allows you to enter points by typing in the x
and y values. This is kind of a pain (I don't recommend that you do this
often), but it's useful if you want to enter a specific value (i.e., x=3.1416
y=19823.245224349546129524).
<C>. <C> adds the endpoints of the points you specify onto the stack. This
way, you can add further iterations to these points. You have three options for
the endpoints you want to add:
1. Add endpoints of all points on the iteration stack.
This, of course, does just what it says.
2. Add endpoints of the last batch of points iterated.
The "last batch" means the points that were iterated the last time you pushed
<I>. Usually, this is the option you want.
3. Add endpoints of the points you specify by number.
Iterate! numbers the points on the stack, starting naturally with 1. You can
see how the points are numbered, as well as the X and Y values of the points
by pressing <L>.
Using this option, you must enter the number of the first point and the
number of the last point you want to continue iterating. Use this option
only if for some reason you want to continue iterating only one or two
specific points.
<L>. <L> lists all points on the iteration stack: their point number, X value,
and Y value, and the X and Y value of their endpoints. <L> also gives other
relevant information on the iteration stack: how many points are on the stack,
how many have been iterated, and which points were iterated in the last batch.
<I>. <I> iterates the points on the iteration stack. Each point is iterated the
number of times you specified with the <T> command.
You can interrupt <I> by pressing any key. Resume where you left off by
pressing <I> again.
User Function Commands
──────────────────────
<U>. <U> allows you to test the user function. Just enter the X and Y values
you want to evaluate, and Iterate! shows the X and Y values the user function
returns. (See the section on "USER FUNCTION" for more details.)
<E>. <E> allows you to edit the current user function file.
You are first presented with a menu that allows you to choose the User Function
Filename. You can choose one of the pre-existing files, or type in a new name
if you want to start a new User Function File. Your User Function should end
with ".frm"; Iterate! changes the extension to ".frm" no matter what you try
to put in.
The User Function Filename you select here becomes the default User Function
Filename--this file will be used as the User Function File until you press <E>
and select a different file.
After you have selected the User Function File, you can edit it. Change it any
way you want, and press <Enter> when you're done. (See the section below on
"The User Function" for more info on how to do this.)
When you finish editing the file, Iterate! reads the file in as the current user
function, sets the Function to U, changes the Parameters to the default
parameters in the function file, and changes the Graphics Window to the default
graphics window entered in the function file.
In other words, after you edit the function file, Iterate! sets you up to try
out your changes (why else would you have been editing it?).
By default, Iterate! uses its own small built in text editor. With this
editor, you are limited to a 22 lines of 75 characters each. For most User
Function Files, this should be more than sufficient. However, if you want to
be able to edit longer files, or if you have another (small) text editor you
like better, Iterate! allows you to specify a text editor to use in editing
the User Function File. Just use the <G> command (see the <G> command above
for more details).
Warning: Any file you edit with Iterate!'s built in User Function Editor will
truncate the file at 22 lines of 75 characters each. If you inadvertently
load a longer file into the User Function Editor, just use <Esc> to back out
and your file will be unharmed.
See the section on "USER FUNCTION" for more details about how to make your own
User Function Files.
Edit Menu Commands
──────────────────
Whenever you're in an edit menu, the following commands are operative:
<Enter> or <Left Mouse Button> accepts all values.
<Esc> or <Right Mouse Button> aborts and sends you back to the command screen.
All values revert to their previous state.
<F1> returns the current field to its default value (what it was before you
started typing).
<Ctrl-End> deletes from the current cursor position to the end of the field.
<Ctrl-Home> deletes from the current cursor position to the beginning of the
field.
All the other keys work pretty much the way you'd expect them to.
THE USER FUNCTION
═══════════════════════════════════════════════════════════════════════════════
One of the spiffiest features of Iterate! (if I do say so myself) is the user
function. The User Function allows you to enter your own function in a User
Function File. The program then treats this function just like any other
function--you can choose it, set parameters, and iterate it.
Using the <F> command and choosing Function U makes the User Function the
current function.
The first time you use Iterate!, the User Function File is named
"Iterate!.frm". You can use the <E> command to select different User Function
File, edit the current User Function File, or make a new User Function File.
Several examples of user functions are distributed along with Iterate!. These
all have the extension ".frm". To try out these formulas, just choose <E> and
select the file you want to try. I suggest looking these over to see what
kinds of things you can do with the User Function; this will probably tell you
more about programming user functions than what I'm about to say.
User Function Files are just plain old text files, so if you're not in
Iterate!, you can edit them with any text editor, such as "Edit" that is
distributed along with DOS.
If you don't like Iterate!'s built in User Function File Editor, you can use
your own text editor to edit User Function Files from within Iterate!. See
the <G> command above for more info.
Iterate! pre-processes the User Function so that it is quite fast--only
60-80% slower than the built in functions. Not bad, considering that the
built in functions are compiled while the User Function is interpreted.
If you come up with a good function file, I am interested in hearing about it.
Send me a disk or printout, or use e-mail. I will distribute the best User
Function Files (with credit given where due, of course) with future versions
of Iterate!.
All right, now down to the nitty-gritty . . .
The User Function File
──────────────────────
Here's an example of a typical user function file:
................................................................................
;This is the name. It will be displayed at the <F> command.
N X= cx + cos(ay) + sin(mu x) Y= dy + sin(bx)
;These are the default values for the parameters
a=1
b=.5
c=1
d=1
mu=.2
;These are the default values for the graphics window
xmin=-20
xmax=20
ymin=-20
ymax=20
;This is the actual function
x= c*x + cos(a*y) + sin(mu*y)
y= sin(b*x) + d*y
................................................................................
The file consists of three parts: The name, the defaults, and the function. The
three parts can be in any order. The name and the defaults are optional.
Only the function is required.
General Notes:
All leading and trailing blanks are ignored.
Comments can be entered by starting the line with a semi-colon.
Anything the formula interpreter doesn't understand is simply ignored; you may
or may not get an error message when the program reads in the function file.
Upper and lower case can both be used; it makes no difference.
>The name<
The name is totally optional. If you don't enter a name, the program will
automatically make a name from the function formulas you entered.
Suppose, however, that you don't want your formula to have just a plain vanilla
algebraic name. Suppose you want it to have a really spiffy name like
'Phred's Phantastic Phormula Phor Phabulous Zucchini Phry Bread'. Well, unless
you took a very different algebra class than I did, this name really isn't
going to work out as your function formula. So the name line lets you specify
'Phred's Phantastic Phormula . . .', or whatever else you might want, as the
name.
Begin the name line with 'N'. Everything after that is the name of the
function. Spaces between the 'N' and the next character are ignored.
The name can be at most 75 characters long. If the name is too long, it will
cause weird things to happen to the display.
>The defaults<
These are the parameters and window settings that will be entered if the user
wants the default parameters and windows settings. If you edit the User
Function File using the <E> command, these parameter and window settings will
be automatically entered as the parameters and window when you're done editing.
The lines beginning with a=, b=, c=, d=, and mu= refer to parameters. The lines
beginning with xmin=, xmax=, ymin=, and ymax= refer to the graphics window.
The defaults are totally optional. Some, all, or none of them may be entered.
However, they are nice for the user (and even yourself), because the values can
be ever after entered automatically if you set them once in the file.
All 9 possible defaults are shown in the example above. Each must be on a line
of its own. Spaces are allowed anywhere as "window dressing"; they will be
ignored.
The number you enter after the equals sign must be able to be interpreted by
TurboPascal as a real number. Otherwise, it will be interpreted as '0'.
A few examples:
Example Remark
───────── ──────────────────────────────────────────────────────
a = 1.09 OK
mu= -3.43 OK
xmax=1e9 OK--this means 1*10^9
y min= 1 0 OK (But c'mon--try to learn how to type. It's not that
hard)
b=i89 Bad--Pascal can't interpret 'i', so sets b=0
c=x Sorry, won't work. Try a real number instead.
>The function<
This is the trickiest part.
The 'x=' introduces the x part of the function, the 'y=' introduces the y part
of the function (for the reason there are two parts to the function, read above
under the <F> command).
The functions are entered in the usual algebraic notation. Spaces are allowed,
but they are "just for looks" and will be ignored.
Example Remark
──────────────── ───────────────────────────────────
y = cos(x*y) All these lines will be interpreted
y=cos(x*y) the same way
y= cos ( x * y )
The function must be on one line. However, this line can be up to 255
characters long. (Iterate!'s built in text editor only allows lines of 75
characters, so if you want to enter functions longer than 75 characters, you
must use your own text editor to edit the User Function File. Remember that
you can use the <G> command to change the text editor Iterate! uses.)
Here are the things you can enter in a function:
Item Example Remark
─────────────────── ────────────── ────────────────────────────────────────
Variable x y The value of x or y
Parameter a b c d mu The current value of this parameter
Constants e pi Enters the value of these constants
Numbers 5 1e3 .35 Must be able to be interpreted by
TurboPascal as a number
functions cos sin (etc.) Performs the operation--a complete list
of recognized functions follows
algebraic operators + - * / ^ Performs the operation
Parentheses ( ) Iterate! can handle as many nested
parentheses as you can fit on a line.
(It can handle up to 500 pending
operations. If anybody can figure out
how to get 500 pending operations on a
line with 255 characters, I'd like to
hear about it!)
This is a list of all operations available in the User Function.
Name Remarks
─────── ────────────────────────────────────────────────────────────────────
* Multiplication
/ Division
+ Addition
- Subtraction (Note: '-' in front of a number, variable, or parameter
gives the additive inverse, just as you'd expect. That is, -3--1=-2,
and -x+y is the same as y-x. You'd better appreciate this, because,
believe me, it was a big pain to program. Whoever invented
mathematics ought to be shot for allowing one symbol to stand for
two different things.)
(See also Note 5.)
^ Exponentiation, i.e. 2^3=8
# Integer division, i.e. 12#5=2, 21#4=5, 100#49=2. Division by zero
returns 0, i.e. 100#0=0.
| Modulus, that is, a|b is the remainder of a/b. For instance 12|5=2,
21|4=1, 100|49=2. x|0=0 for all x.
sqr the square of the number, i.e. sqr(10)=100. Sqr(x) should be faster
than x*x
sqrt the square root of the number, i.e. sqrt(100)=10. Sqrt of a
negative number returns 0.
sin All trig functions are calculated in radians
cos
tan
cot
sec
csc
arcsin Results of inverse trig functions are given in radians
arccos
arctan
arccot
arcsec
arccsc
sinh Hyperbolic trig functions. These functions have tendency to return
cosh very large and very small numbers. Any result larger than 1e16
tanh is simply truncated to 1e16. Any result smaller than about 1e-16
coth is simply set to 0.
sech
csch
arcsinh
arccosh
arctanh
e enters the value of e=2.71828...
pi enters the value of pi=3.141592...
exp exponential of the number, i.e. exp(1)=2.71828, exp(2)=7.38905
exp10 10 to the power of the number, i.e. exp10(1)=10, exp10(2)=100
logn natural log, i.e. logn(e)=1. Logn of a negative number returns 0.
log log base 10, i.e. log(10)=1. Log of a negative number returns 0.
inv multiplicative inverse, i.e. inv(x)=1/x. This should be faster,
however, than 1/x
neg additive inverse, i.e. neg(cos(x))=-cos(x). Use 'neg' instead of '-'
if you wish to restore symbolic purity to mathematics and keep
programmers out of the loony bin. Just as fast as '-', might
work more reliably, and it's _unambiguous_.
abs absolute value, i.e. abs(3)=3, abs(-3)=3
sgn the sign of the number, i.e. sgn(10)=1, sgn(-10)=-1, sgn(0)=0
int next integer smaller in absolute value, i.e. int(1.4)=1, int(-3.5)=-3
round rounds to the nearest integer, i.e. round(2.1)=2, round(3.6)=4,
round(10.7)=11. .5 rounds to the next larger integer in absolute
value, i.e. round(2.5)=3, and round(-2.5)=-3
rn a random real number between 0 and 1 (more precisely, rn may equal
zero, but will always be less than 1)
intran a random whole number less than the argument and greater than or equal
to zero, i.e. intran(10) is somewhere in the range 0..9
(Actually I have heard that there is a bug in the TurboPascal random
number generator that will make rn=1 and intran(10)=10 two times or
so out of every billion. If this disturbs you, I suggest that you
write a nasty letter to Borland.)
NOTES:
1. Normal algebraic precedence of operation is used:
Function Precedence
────────── ───────────────────────────────────────────────────────────
sin, cos, 1 highest precedence (P.S. also includes '-' when used as a
all other unary operator--did I tell you it was
unary a pain?)
functions
^ 2
*,/,#,| 3
+,- 4 lowest precedence
2. The User Function Interpreter attempts to prevent overflow errors. If the
absolute value of x or y is greater than 1e16, the function simply does not
calculate--x and y are left unchanged. If your function is really wild, though,
you could possibly generate overflow errors. If this happens, the program will
stop and display a runtime error.
3. The Interpreter also attempts to prevent division by zero errors. If
division by zero is attempted (or anything similar such as cot(0)), 1e16 is
simply substituted as the result.
4. Some functions are undefined for negative numbers (sqrt, log, logn). If
you input a negative number into these functions, they will simply return 0.
This is again to prevent runtime errors that would halt the program. The
problem with this, however, is it can give unexpected results--the function
looks like it is doing something, when really it is in an area where the
function isn't even defined. I suggest using the 'abs' function in
conjunction with these functions, i.e., use sqrt(abs(x)) instead of just
sqrt(x). Or just don't use points that will give a negative result. At
any rate, be a little wary of results using these functions.
5. One thing the Function Interpreter will not handle is things like this:
--(x+5), --x, y+--x
As you can see, there is a double (unary) negative sign in each of these
functions. Don't use this, as it will give unexpected results. (Don't ask
me WHY you would want to do this anyway, but I'm sure there is somebody
out there who is going to be bitterly disappointed that they won't be able
to put a bunch of superfluous minus signs in all their functions.)
The Function Interpreter WILL handle things like this:
x--5, -(-(-x+-5)), neg(neg(neg(-5))), x--(-5--y)
Notice that there are double minus signs here, but in every case, one of them
is a binary minus sign (subtraction) and the other is unary minus sign
(negative sign). Two or more unary minus signs in a row is what the Function
Interpreter can't handle.
Here are some examples of functions, just to give you an idea of the types
of things you can do.
Example Remark
────────────────────── ───────────────────────────────────────
x=x*sin(a*y/x^5) Normal algebraic precedence is observed
y=y/-a*log(x*(y+b)) Nested parentheses allowed
x=x + CSC (Y) Spaces are OK; upper case is OK
y=(x+y)*pi
x= rn * abs(x)
y= y | intran(5)
x= y # x
y= log(e * x)
x= sin(x*pi/180)
y= sgn(a*x+b*cos(y))#x
User Function Error Messages
────────────────────────────
Iterate! tries to detect errors in the function file and give helpful error
messages.
Iterate! reads the User Function on three occasions:
1. When you start the program
2. When you return from a DOS shell
3. After you use the <E> command to edit the User Function File
So these three occasions are when you may see error messages related to the User
Function File.
Because of the way Iterate! processes the function file, it is difficult to
point out after the fact exactly where the error occurred. So you have to take
Iterate!'s error messages with a little grain of salt. If Iterate! says the
error occurred at "cosx", then the error probably happened at or near "cos" or
"x" in your file.
If an error occurs, you will still be able use the User Function (of course it
may not be working properly!).
On the other hand, it is possible that Iterate! won't give you an error, but the
function still won't be working properly--either because Iterate! thinks it
understands something that it really doesn't, or simply because you didn't enter
what you really meant.
This could create problems, but the solution is really quite simple: Use
the <U> command to test your function. Calculate a couple of values by hand,
and then enter these same values at the <U> command. If you get the same
answers as you did by hand, you can be pretty darn sure that the function is
working right.
GRAPHICS MODES
───────────────────────────────────────────────────────────────────────────────
Automatic detection
───────────────────
Iterate! automatically detects CGA, EGA, VGA, and Hercules graphics and starts
you in the right graphics mode.
If you don't have one of these adapters, or if Iterate! can't detect which
adapter you have, it will kick you into a graphics menu when you first start the
program. You can manually choose your graphics adapter and mode. Just type the
number of the proper graphics adapter and mode when they are requested.
Because it is impossible to tell which graphics adapters might be compatible
with which graphics modes, the program puts no restrictions on which adapter you
may choose. If you choose an incompatible adapter, however, you might hang your
computer. If this happens, try pushing <Ctrl-Break> to exit the program. If this
doesn't work, you will just have to reset the computer.
>Choosing graphics mode at the command line<
If you don't like the mode Iterate! puts you in automatically, you can specify a
different graphics mode from the DOS command line. These command line options
are available:
Command What it does
───────────── ───────────────
Iterate! CGA CGA mode 4
Iterate! EGA EGA mode 2
Iterate! Herc Hercules mode 0
Iterate! VGA VGA mode 1
Iterate! VGA0 VGA mode 0
Iterate! VGA1 VGA mode 1
Iterate! VGA2 VGA mode 2
Iterate! Man Allows you to manually choose graphics modes
There should be a space (not a slash, dash or anything else) after Iterate! and
before the command line option. Upper or lower case is OK.
Compatibility
─────────────
Iterate! has been thoroughly tested with CGA, EGA, VGA, and Hercules graphics
adapters, and should work fine if you have one of these. If you have anything
else, it might work, but I don't guarantee anything!
If you can't get the program to work any other way, you might try CGA, EGA, or
VGA mode. Most graphics adapters are compatible with one of these.
Memory restrictions on graphics mode
────────────────────────────────────
Iterate! Saves your entire graphics screen to memory when it switches to text
mode. As you can well imagine, this takes a huge chunk of memory--around
170,000 bytes for VGA2 mode (640x480, 16 colors).
At startup, Iterate! reserves about 180,000 bytes for storing the graphics
screen.
So what's the point? If the graphics mode you choose requires more than 180,000
bytes of storage, choosing that mode will generate a run-time error (a heap
overflow error, just in case you're interested).
So . . . . . . don't choose a graphics mode that requires more than 180K of
memory! Anything with a resolution of more than 640x480 or with more than
16 colors is likely to require more than this.
You're welcome to give higher resolution/color modes a try. You won't hurt
anything. If you run into problems, just choose a lower resolution mode or a
mode with less colors.
256 colors won't do you any good in this program anyway! It's all 2 colors--
black and white. Anything more than that just bogs things down and makes the
save files that much bigger.
MOUSE
═══════════════════════════════════════════════════════════════════════════════
The mouse utilities I used in Iterate! will supposedly work with any Microsoft
compatible mouse. I have tested it with GMouse (the Genius Mouse Driver)
version 8.08, Logitech's Mouse Driver version 6.12, and Microsoft Mouse
Driver version 8.10.
If the mouse doesn't work right with Iterate!, you can try a few of things:
* Get an updated mouse driver. Your older mouse driver might not be
compatible with newer video modes or a later Microsoft mouse standard.
You should be able to get an updated mouse driver from the manufacturer
or the place you bought the mouse. Sometimes manufacturers distribute
updates electronically; you may be able to find a driver that works on a
local BBS.
* Just use the keyboard. You can do anything with the keyboard you can do
with the mouse (OK, OK, it's not as much fun, but that's the breaks, kid).
* Prevent Iterate! from using the mouse by typing "Iterate! nomouse" at the
command line. Then just use the keyboard. You should try this if you're
unable to make the cursor move to all parts of the graphics screen; the
problem in this case is the mouse driver, not Iterate!.
* Report the problem to me. Especially if you're a registered user (!!) I
might be able to figure something out.
One little mousey bug: if you are moving the mouse when you start the program
(when Iterate! is running its mouse initialization routines), Iterate! won't
recognize the mouse and you won't be able to use it. This seems to be a bug
in the mouse driver itself, or in the mouse utilities I am using. Sorry.
PRINTING
═══════════════════════════════════════════════════════════════════════════════
For printing your creations, I suggest using "Graphics.exe" or "Graphics.com"
that comes with your copy of DOS.
Just type "Graphics" at the DOS prompt, before starting Iterate! (Make sure
Graphics.exe or Graphics.com is in your current directory or path. Usually, it
is found in the DOS subdirectory, which is in usually in your path, so just
typing "Graphics" will work.)
Then, when you're in Iterate!, press <Shift-PrintScreen>, and whatever you're
looking at will be printed out to your printer.
If this doesn't work, check your DOS documentation under "Graphics" or your
printer documentation under "Printing the Graphics Screen."
If you have a 386 or better computer, it is also possible to print a graphics
screen using Windows. Run Windows in advanced mode, and then run Iterate! in
a window. Then <Alt-PrintScreen> will copy the current window to the
clipboard. You can run your favorite graphics program, paste the Clipboard
into it, and print from there.
RUNTIME ERROR MESSAGES
═══════════════════════════════════════════════════════════════════════════════
On some (hopefully very rare) occasions, Iterate! will terminate abnormally
because of an unexpected runtime error. If this happens, Iterate! will present
you with a screen telling you the type of error that happened and (if you're
lucky) giving you a chance to save your graphics screen.
If this happens to you, I would appreciate it if you would write and tell me
what happened, what error message and error address were reported, and what
you were doing at the time. It would also be helpful if you would describe
your system (CPU, video card and mode, mouse driver, etc).
Here are a couple of the more common errors and what might be causing them:
Heap OverFlow Error
───────────────────
This is most likely to happen if you choose a high resolution video mode and
you don't have enough memory free (or if Iterate! automatically chooses such
a video mode for you). It can also happen if you try to load a graphics file
from disk, and the graphics file was made in a higher resolution video mode
than you are currently using.
This error happens because when you switch to a text screen, Iterate! saves the
current graphics screen to conventional memory (on TurboPascal's "heap"). If
there isn't enough conventional memory free to save the graphics screen, you get
a heap overflow error.
Solutions:
* Choose a lower resolution video mode. (See "GRAPHICS MODES" for more
details.)
* Remove Unnecessary TSR's.
* Change your config.sys and autoexec.bat files so that less TSR's are
loaded at startup.
* Use Himem to load DOS high.
* Use EMM386 or a similar memory manager to load your TSR's high.
"Floating Point Overflow Error" and "Division by Zero Error"
────────────────────────────────────────────────────────────
These errors and other similar errors ("Underflow" or "Overflow" Errors or any
kind of "Floating Point" error) are most likely caused by the User Function.
Iterate! tries to prevent these kinds of errors, but it is probably possible
to cause them if you try hard enough.
If this happens, I would appreciate it if you would write me with the function
and the values that caused the problem.
Other possible causes are the built in functions, or a corrupted .exe file.
Solutions:
If you think the User Function caused the problem:
* Change the User Function
* Don't enter very large or very small values (greater than 1e16 or less
than 1e-16)
Otherwise:
* Write me for an uncorrupted Iterate!.exe file
MISCELLANEOUS PROGRAM INFO
═══════════════════════════════════════════════════════════════════════════════
Iterate! is written in TurboPascal 7.0.
Believe it or not, I have been working on Iterate! off and on for about two
years now. It began life on my XT compatible, in TurboPascal 3.0.
Iterate! has a cousin, Itermold, which translates these iterated points into
music. Unfortunately, Itermold is nowhere near public release, and probably
never will be. It sounds really nice on my synthesizer, though.
If you have any questions, comments, or suggestions about Iterate!, you can
contact me at
986 Raymond Road
Fruit Heights, UT 84037
USA
voice phone: (816) 356-1740 or (801) 544-5032
Internet : bhugh@vax1.umkc.edu
FidoNet : Brent Hugh 1:280/305
I might be able to add any particular features you would like (additional
functions for the User Function, etc.)
I would particularly like to hear about any bugs you find.
UPCOMING ADDITIONS
═══════════════════════════════════════════════════════════════════════════════
I am planning to add some features to the next version of Iterate! Send your
registration fee in, and I'll get them done faster!
Also, registered users will receive a copy of the latest version . . . and
by the time you're reading this, maybe the latest version with these spiffy
new features is all finished.
Coming attractions . . .
* Save graphics files in a better format such as GIF or PCX
* Provide built in printer support
* Iterate in 3-D
* Add more Mandelbrot-Julia Set type functions that can be investigated
by using Iterate! and the Mandelbrot-Julia generator together
* Improve User Function to use If-then statements
* Add support for complex numbers to the User Function
* Improve help system
* Specify default number of iterations in User Function Files
* Use colors to show how many times a point has been hit
* Make it smaller and faster
* Anything you would like and let me know about
BIBLIOGRAPHY
═══════════════════════════════════════════════════════════════════════════════
Most of these books should be available at your local bookstore. Others can be
ordered from Math Products Plus, PO Box 64, San Carlos, CA 94070, (415) 593-
2839.
Computers and the Imagination, by Clifford A. Pickover. St. Martin's Press, New
York, 1991. Poses fascinating problems; a lot of interesting references.
Computers, Patterns, Chaos, And Beauty, by Clifford A. Pickover. St. Martin's
Press, New York, 1990.
The Fractal Geometry of Nature, by Benoit Mandelbrot. Freeman, San Francisco,
1983. The seminal book on fractals; relatively non-technical.
The Beauty of Fractals, by H. Peitgen and P. Richter. Springer, Berlin, 1986.
Fabulous color pictures of fractals make up the bulk of this book.
The Science of Fractal Images, by H. Peitgen and D. Saupe. Springer, Berlin,
1988.
Chaos, by James Gleick. A popularization of chaos theory and its many real
world applications. Available in many bookstores.
An Introduction to Chaotic Dynamical Systems, by R.L. Devaney, Benjamin-
Cummings, Menlo Park, California, 1986. A very good introduction to the more
technical side of Iteration Theory. It is comprehensible by anyone who has
had a couple of semesters of calculus.
Turbulent Mirror--An Illustrated Guide to Chaos Theory & the Science of
Wholeness, by J. Briggs and E. D. Peat. Another popularization with plenty of
pictures.
Fractals, by Jens Feder. Plenum, 1988.
Fractals Everywhere, by Michael Barnsley. Academic Press, 1988.
Various articles in Scientific American on fractals and chaos. The math and
computer columns in Scientific American regularly have interesting articles.
(Ver. 3.11, 9/93)