Received: from lists.xmission.com (lists.xmission.com [198.60.22.7])
	by mail-atm.san.rr.com (8.8.7/8.8.8) with SMTP id CAA29347;
	Fri, 2 Jan 1998 02:37:15 -0800 (PST)
Received: from domo by lists.xmission.com with local (Exim 1.73 #4)
	id 0xo4OC-0000ao-00; Fri, 2 Jan 1998 03:31:40 -0700
Date: Fri, 2 Jan 1998 05:32:49 -0500 (EST)
Message-Id: <199801021032.FAA18325@freenet5.carleton.ca.carleton.ca>
From: ao950@freenet.carleton.ca (Paul Derbyshire)
To: fractint@lists.xmission.com
Subject: Re: (fractint) Formula Question
Sender: owner-fractint@lists.xmission.com
Precedence: bulk
Reply-To: fractint@lists.xmission.com
Content-Type: text
X-UIDL: a2d372211e4620497e03c2502d69da1f

>Is it a geometry thing? Or Trig? *sigh*

No, no, it's not geometry or trig... it's far, far, worse.

It's calculus.


<listens to various modems hanging up and NO CARRIERs popping on people's
terminals, one heart attack, two burst cerebral aneurysms, and five
nervous breakdowns>

Okay, those of you still listening: The best formulas for iteration have
multiple critical points; places where the deriuvative (consult your
entry-level calculus text) goes to zero. The rest have one, but never ever
ever zero.

Take the regular M-set formula. It is z^2+c. The derivative is 2z, which
is zero when z is zero (twice nothing's still nothing). Thus, it has one,
so there are fascinating julia sets more than likely (and indeed there
are) and an M-set. The Julia sets are obtained by fixing a value for 'c',
different for each Julia set, and varying z to get an image:

z=pixel, c=p1:
z=sqr(z)+c,
lastsqr<p2


The M-set is had by setting z=0, the critical point, and varying c:

z=0, c=pixel:
z=sqr(z)+c,
lastsqr<p2

Now look at the formula z^3-3*c*z+c. The derivative is 3z^2-3*c, or z^2=c,
or z=+/- sqrt(c). Thus there are two critical points. Each gives an M-set:

c=pixel, z=sqrt(c):
z=sqr(z)*z-3*c*z+c,
lastsqr<p2

c=pixel, z=-sqrt(c):
z=sqr(z)*z-3*c*z+c,
lastsqr<p2

And Julia sets like so:

c=p1, z=pixel:
z=sqr(z)*z-3*c*z+c,
lastsqr<p2


Also, to avoid a solid black screen, make sure the thing will tend to
infinity for some z!
Polynomials of at least 2nd degree work. Any Newton formula or twist upon
same will work. Any rational where the degree of the numerator exceeds
that of the denominator, or a term that increases with z is added to the
quotient, will work. Trig works because the sin and cos functions go to
infinity for large imaginary values, even though the familiar sine wave is
bounded. That bounded wave is only what goes on on the real axis and isn't
the whole picture.
Logs go to infinity, but too slowly. The derivative should exceed the unit
circle for z bigger than some bound. This means the modulus of f'(z)
should be greater than 1 for z with a modulus exceeding a certain bound.

Note that some formulas e.g. Newton don't adhere to these rules much! They
generate stuff because they still have many attractors. But since all are
finite, things are trickier. You must spot the finite attractors and make
an orbit trap aroun them:

PlainNewton {
  z=pixel:
  z2=sqr(z)
  z=z-(z*z2-1/(3*z2)),
  |z-1|>p2
}

This is the Newton iteration for z^3-1, with an orbit trap around 1. The
last line before the lone close brace is the orbit trap.

For a Newton fractal, an orbit trap of a different type works:

  z2=sqr(z)
  diff=(z*z2-1/(3*z2))
  z=z-diff,
  |diff|>p2

This catches all three attractors. Because the difference between the old
and new z is "diff", if diff gets close to 0 and stays there, z has hit a
point attractor. This thus traps orbits around all three attractors.

If you are unsure of the locations of attractors, or they vary based on c
or are too complicated to bother with (like two of the three in the Newton
iteration above), just trap for a z that stays put:

  oldzed=z
  z=...etc.etc.etc.
  |oldzed-z|>p2

(Note: All of these use p2 as a bailout. If p2 is left the default 0
expect blank looks from your computer! Literally. Instead set a small
value, like 0.001, and use float=y.)

By keeping older zeds:

olderzed=oldzed
oldzed=z
...
|z-olderzed|>p2

you can trap for both fixed point and 2-cycle attractors, whilst making
false alarms with 2-cycles less likely.

Note that for orbit traps around finite attractors, often periodicity=0 is
needed to get a picture at all, or else to get rid of bogus black squares.

You can trap for longer cycles without doing any work at all by
capitalizing on Fractint's periodicity checking. This time leave
periodicity ON! All you have to do is have no orbit traps at all (except
maybe at infinity), count iterations (iter=0, ..., iter=iter+1,...), and
then on termination have your thing set z to iter on the last iteration,
or 0 if iter==maxiter. Generate using outside=iter, inside=zmag, and
you'll get any infintie basin colored by iteration, any finite basins
colored by iteration, and points that never were trapped by periodicity
cheking colored color zero.


When you're making formulas, calculus is your friend.


--
    .*.  Friendship, companionship, love, and having fun are the reasons for
 -()  <  life. All else; sex, money, fame, etc.; are just to get/express these.
    `*'  Send any and all mail with attachments to the hotmail address please.
Paul Derbyshire ao950@freenet.carleton.ca pgd73@hotmail.com

-
------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   fractint@xmission.com
Get Commands:   majordomo@xmission.com "help"
Administrator:  twegner@phoenix.net
Unsubscribe:    majordomo@xmission.com "unsubscribe fractint"