ftp.xmission.com/2014.06.ftp.xmission.com.tar/ftp.xmission.com/pub/lists/fractint/archive/v01.n088

Internet Message Format | 1998-01-23 | 70KB

From: [e-mail] (fractint-digest)
To: [e-mail]
Subject: fractint-digest V1 #88
Reply-To: fractint-digest
Sender: [e-mail]
Errors-To: [e-mail]
Precedence: bulk


fractint-digest        Friday, January 23 1998        Volume 01 : Number 088




----------------------------------------------------------------------

Date: Thu, 22 Jan 1998 22:38:12 -0800
From: "Jay Hill" <[e-mail]>
Subject: (fractint) FotN web pages and FotN 22 Jan 1998 (Manta)

F.O.T.N. (Fractal of the Night) 22 Jan 1998 (Manta)

Having played with his starfish about as much as one can,
(Starfish) http://home.san.rr.com/jayrhill/FotN/FotN21.html
Dr. J, the mad scientist, decided he should put it back
where he found it.  Not a problem, since he had noted its
coordinates at the edge of fractal land the night before.
As he approached the beach, things just didn't look right.

Before he could figure out what the matter was, he found
himself neck deep in the sea. "Something awful is down here!"
he told himself.  On these matters he was usually correct.
Only the fact that the Manta was not hungry saved him from
becoming munchies for the giant Manta (see tonight's picture).
Finally back at the lab he discovered his nearly fatal error.
He had left the lab with the wrong formula loaded into
his Fractomap(tm). What you expect to find with one formula
most certainly will surprise you with another.

Yes, set your Fractomap to the formula by Michael G. Wareman.
Sometimes, you compute a Julia set, and find it is mostly solid
(the point in the corresponding MSet is slightly inside a
component). Some of these are pretty boring, a bunch of ripples
around the edge.  This happened with tonight's fractal. But when I
tried inverting it, I got something more to my liking.

Here are the Fractint parameter files.

Enjoy
Jay

A web page is here.
http://home.san.rr.com/jayrhill/FotN/FotN22.html

An index into the FotN so far.
http://home.san.rr.com/jayrhill/FotN/FotNindx.html


frm:FGZ-Julia   { ; (c) Jay Hill, 1998
  ; generalization of formula by Michael G. Wareman
  ; p3 is focus of Julia set
  z=pixel, c=p3:
  z1=z*z + c;
  z = p1*z1*z1/(z1 + p2) + c;
  |z| <= 16
  }

Manta    { ; (c) Jay Hill, 1998
           ; generalization of formula by Michael G. Wareman
           ; p1 is focus of Julia set
           ; FGZ-J55i
  reset=1960 type=formula formulafile=fgz.frm formulaname=fgz-julia
  center-mag=-0.535207/3.55271e-015/0.4681297/1/90
  params=3/0/3/0/-0.552/0 float=y maxiter=255 inside=bof60
  outside=atan invert=1/-0.551/0
  colors=cw0UfU0MU<27>0Lb0Kc0Lc<6>0U`<7>\
  UcY<131>UYaUYaUYaUXaUXaUXa<7>UUcUU\
  cUTb<58>U0A1AF1AF
  savename=Manta
  }


- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 01:25:56 -0800
From: "Jay Hill" <[e-mail]>
Subject: (fractint) 3D glasses for Fractint viewing...so many to view

Hi gang,

Did you know Fractint can make 3D images which you view with
those funky Red and Blue glasses?  Ever wonder where you
could get them for cheap?

I can get you as many as you want for just $4 per pair, er make
that per two pair (4 eyes worth). Now that is only $1 per eye!!
And as a bonus you can have 27 dazzling images of great
astronomical prints!  Does this sound like another SPAM from
Jay?  Well OK, I really don't want to have to go through a sales
pitch any more than you. Least of all, make deliveries.

So I won't!!  :-)

Just point your transportation device toward the nearest magazine
sales rack and get the March 1998 issue of Astronomy, $3.95.

BTW, we are getting some really great posts about advanced
formula writing.  I'm still hoping for lesson 101 showing the basic
MSet plot with these methods. I'm considering posting my
Fractal of the Night to the Fractal-Art list only. That should cut
down on the traffic some. I assume all you all subscribe to both.
In any case you can visit my web page for catch-up view.

It looks like my web page at home technique first introduced in
the contest is catching on. It could well become the future for
this list. The only problem is there are a few folk who are only
on email.

Frankly, I don't think a token par posted makes up for an off
topic post.  I made the off-hand remark earlier that we would
soon have our hard disks filled with off topic posts just for the
image pars. The good posts being long lost. This is indeed
coming to pass. We spend all evening snipping and pasting.
I am rapidly developing a real mess. Sometimes I think it
would be better for off-topic posts not have a par. Then I can
just delete it! and be done.

Before the contest we had about 500 posts in half a year.
The Fractal-Art folk threw us out just in time.  The contest
developed a thousand posts in two months (give or take).
Now it looks like a thousand so far in January. I will still try
to create the iFAQ, because out of a projected 10,000 posts
by the end of this year, there will be about 200 pages of
really top quality material.

Are we are seeing what I forecasted? Will you soon have to beg
folk to look at your images, compute your pars or try your formula?
Will we replace (c) which means don't copy with (p) which means
please look?

There are literally thousands of each, pars and formula. Jim
Muth has explored more than a thousand formula.

Not images, formula.

From just one formula, I posted pars for about 20,000 MSet
midgets earlier (to make this very point).  Don't forget,
there is at least one screen saver which automates viewing.
The problem is, live viewing is too slow. But when I run it with
the 20,000 midget files, I find I'm noting down the numbers of
about 20% because they are so cool. The MSet has unlimited
surprises.  But these must be called just average, by definition.

Even when you take into account the works of the really good
artists, the quantity is overwhelming.  There is a series of
Bob Margolis' images running on alt.binaries.pictures.fractals
which alone is near a thousand.  I think archives and collections
will soon require too much labor to view.

Perhaps some automatic version of my contest web pages
would help.  One should be able to get a segment, unzip it,
and run a batch construction file over night. Then in a few
minutes over coffee view the several hundred images
followed by blowing away the lot.

How else could you ever keep up??!!  Perhaps you can't.

Pleaaaase don't let this post dampen any spirits, I'm really
enjoying the flood. I actually view every par posted. I'm just
trying to invent another device to help us, like I did with the
contest.  So if anyone has a GOOD idea what to do with
all these fractals, let us know.

Then we will all know where to stick this one....

AlienShip          { ; (p) Jay Hill, 1998
                     ; uses invert to get nice ship lines
                     ; fgz-m-551i
  reset=1960 type=formula formulafile=fgz.frm formulaname=fgz-mand
  center-mag=-2.91055/5.32907e-015/0.1909855/1/90 params=3/0/3/0/0/0
  float=y maxiter=256 inside=bof60 invert=1/-0.551/0 decomp=256
  colors=wK0<6>AAA<22>111000001\
  <45>0Tu0Uw0Uw<171>022111000000
  }

frm:FGZ-Mand  { ; (p) Jay Hill, 1998
  IF( |p3| == 0)
    p3 = 16
  ENDIF
  c=pixel, z=sqrt(-c), bailout = real(p3):
  z1=z*z + c;
  z = p1*z1*z1/(z1 + p2) + c;
  |z| <= bailout
}

Jay
PS. The Astronomy magazine is a really good one!


- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Sat, 17 Jan 1998 22:52:35
From: "Lavondyss" <[e-mail]>
Subject: Re: (fractint) hello

Jean-Pierre

I do not know the creators of the fractals that I posted. I gave credit
where I knew the creator. Like the Frosty.
As for the background, I tried to leave it untouched as best as possible.
Thanx for visiting and sending some comments!


- -Lavondyss




- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Sat, 17 Jan 1998 22:56:15
From: "Lavondyss" <[e-mail]>
Subject: Re: (fractint) hello

Thanx for visiting Angela. I'm starting on my next batch of fractals. But I
don't know when I'll be done and post them. I have lots of papers due for my
college courses, so it might take some time. But anyways, you're welcomed to
link to my page as you see fit. Everything there is FREE, and I mean free
with no strings attatched..^_^.

will be fractaling!

- -Lavondyss




- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 09:35:48 -0500
From: Gedeon Peteri <[e-mail]>
Subject: (fractint) Duplicate messages

These past couple of days I received approximately 20 messages which
were duplicates of postings I already received once several days ago.
And they keep coming; two just this morning. The duplicates do not bear
current dates, but those of the original posting. Is anyone else
experiencing this phenomenon?
Gedeon


- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 06:58:59 -0800
From: "Mike or Linda Allison" <[e-mail]>
Subject: (fractint) [fractint] this is a "can I post yet?" test

Hi, all!

Well, our computer is more or less up and running again.  We're on our 3rd
hard drive in the last 12 months :((

I think I have all the messages posted while I was gone (downloaded
archives), but if anyone sent me any personal messages Saturday or Sunday,
I think they were lost.

This is a test posting to see if I can post to the mailing list yet.  The
test post I made on Tuesday bounced back to me.

If this post makes it to ANYONE, please let me know!  Thanks!

Linda Allison ([e-mail])
http://www.geocities.com/~gumbycat
http://www.fortunecity.com//tattooine/stephenson/5/abpf.html


- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 10:57:55 -0500
From: "Brian E. Jones" <[e-mail]>
Subject: Re: (fractint) Fractal music?

Don Archer wrote:

>>I listen to all the fractal music I can, and there's none better
than Brian's. (And his fractals are terrific too!)<<

Thanks for the super-kind words, Don!!!

I forgot to add that Netscape users won't be able to hear the opening midi
sequence (which I think is one of my better pieces.)
But, if you add:

/seahorse.mid

to the end of my URL, you should be able to retrieve it.

Brian
http://ourworld.compuserve.com/homepages/Brian_E_Jones



- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 11:15:23 -0500
From: Lee Skinner <[e-mail]>
Subject: (fractint) Duplicate mes

Gedeon,

>>These past couple of days I received approximately 20 messages which we=
re
duplicates of postings I already received once several days ago. And they=

keep coming; two just this morning. The duplicates do not bear current
dates, but those of the original posting. Is anyone else experiencing thi=
s
phenomenon?<<

Yes!  Tons of them.  Very annoying!

Lee

- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 17:38:00 +1
From: "J.P. Louvet" <[e-mail]>
Subject: Re: (fractint) [fractint] this is a "can I post yet?" test

le 23 Jan 98 a 6:58, Mike or Linda Allison ecrivait (Mike or Linda Allison
wrote) :

> If this post makes it to ANYONE, please let me know!  Thanks!

Hi Linda,

I read it.

Kind regards.

Jean-Pierre

- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 10:09:04 -0800
From: Mark Christenson <[e-mail]>
Subject: Re: (fractint) Colour-map loading problem

Paul Carlson wrote:
> 4) Loading a colormap messes up the current image.
> ...
> I press
> the 'E' key and then the 'L' key and select a different colormap.
> All works well except that a short line (looks like a minus sign)
> ...

I am having a similar problem with v19.6.  In SF5 mode, an array of
thin vertical slices about 80 pixels tall are removed.  I am not
*currently* having this problem with v19.3, but seem to have a
vague memory (or perhaps a stray dream fragment) of having this
problem early on.  Is it possible that this is a known problem, with
a solution posted somewhere in the mass of Fractint documentation?

Also, thanks to all those who have posted comments on my Netscape
3.x vs 4.x question.  Further input is always welcome.


Later, Bud


- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 16:01:49 -0600 (CST)
From: [e-mail]
Subject: (fractint) **TEST** -- E-mail seems broken

Hi.

Netscape won't connect to my server, so I'm checking to see if the basic
method (telneting into the school's user accounts and using Pine) works.

I haven't received anything lately either.

PARs are forthcoming... ;-)
Justin A. Kolodziej

- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 17:13:46 EST
From: Nature102 <[e-mail]>
Subject: Re: (fractint) Duplicate messages

In a message dated 98-01-23 09:38:00 EST, [e-mail] writes:

<< These past couple of days I received approximately 20 messages which
 were duplicates of postings I already received once several days ago.
 And they keep coming; two just this morning. The duplicates do not bear
 current dates, but those of the original posting. Is anyone else
 experiencing this phenomenon? >>

  Yah, I saw them too. If I didn't know better I'd say that AOL somehow took
over the mailing list or something. :-P

- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 15:11:38 -0800
From: "Jim sellers" <[e-mail]>
Subject: Re: (fractint) Duplicate messages

Yes, I don't pay real close attention but it seems as tho a lot of them are
the same.
Jim

- ----------
> From: Gedeon Peteri <[e-mail]>
> To: Fractint <[e-mail]>
> Subject: (fractint) Duplicate messages
> Date: Friday, January 23, 1998 6:35 AM
>
> These past couple of days I received approximately 20 messages which
> were duplicates of postings I already received once several days ago.
> And they keep coming; two just this morning. The duplicates do not bear
> current dates, but those of the original posting. Is anyone else
> experiencing this phenomenon?
> Gedeon
>
>
> -
> ------------------------------------------------------------
> Thanks for using Fractint, The Fractals and Fractint Discussion List
> Post Message:   [e-mail]
> Get Commands:   [e-mail] "help"
> Administrator:  [e-mail]
> Unsubscribe:    [e-mail] "unsubscribe fractint"


- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 19:22:12 -0500
From: Jack Valero <[e-mail]>
Subject: Re: (fractint) Duplicate mes

At 11:15 AM 23/01/98 -0500, you wrote:
>Gedeon,
>
>>>These past couple of days I received approximately 20 messages which were
>duplicates of postings I already received once several days ago. And they
>keep coming; two just this morning. The duplicates do not bear current
>dates, but those of the original posting. Is anyone else experiencing this
>phenomenon?<<
>
Yes, I also am receiving duplicate (multicate?) messages.

Yes, I also am receiving duplicate (multicate?) messages.

Yes, I also am receiving duplicate (multicate?) messages...



Regards - Jack

visit our fractal gallery: http://www.globalserve.net/~jval/phractal.html

- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 19:35:04 -0600 (CST)
From: [e-mail]
Subject: Re: (fractint) Duplicate mes

Duplicate messages may be caused by someone setting Netscape (now
FREE!!!)  to "Send messages as both text and HTML format."  This sends
TWO messages every time a message is sent.

The fix... set Netscape to "Send messages as text only."  ;-)

P.S.  Receiving mail now works, but I still can't send mail from Netscape
either in Windows or Linux.  Thus the lack of quoting as I got the
message 1st.

Justin Kolodziej
:~(



- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 19:04:25 -0700
From: [e-mail]
Subject: [none]

News from the fractint list administrator. Hi!
Sender: [e-mail]
Precedence: bulk
Reply-To: fractint

First, thanks for the efforts to keep on topic. This pays off.
Because the list traffic is so high, this continues to be important.
I am sure everyone has trouble digesting so many messages, so lets
keep our messages focussed on fractal-related content that we are
confident will interest most of the several hundred list subscribers.

Second, I hereby declare that messages about list administration
issues are off topic, except for my messages <grin!> (I intentionally
restrain myself from posting many messages like this one, but by
definition everything I post is on topic :-)) As much as you might
want to answer my messages with essays about how true it is that
people should stay on topic etc. etc., such messages are *also* off
topic! Similarly, when there are list problems such as the
mysterious posting of old list messages, please don't discuss this
on the list - email me if you think it is necessary.

Speaking of which, I don't know the cause of the recent
reposting of old messages. As long as it happens only rarely, I won't
worry, but if we see it again any time soon I will investigate with
xmission.

The xmission majordomo administrators are investigating why one of
our subscribers (the Carlsons) from netcom.com can't post. (Thanks
to the folks who are relaying his their messages to the list so he
can post, albeit indirectly.) His messages bounce with headers that
say his address is "forbidden by the administrator" or some such. If
you ever see such a bounced message (bounced by xmission itself, not
bounced by majordomo) let me know, and DON'T take it personally.
NOBODY is trying to screen you out, least of all me. If I ever have
to ban someone I'll let them know why! I do sometimes have to delete
subscribers who can't receive list messages, which then all bounce to
me. Necessarily I can't explain to such folks what I did - they can't
get mail. If that happens to you (you'll know because you'll stop
getting list messages), just resubscribe.

Recently the findmail folks subscribed their system to our list
(without advance permission), and mirrored it on a web page.
They informed me after the fact. I requested they discontinue it, and
shortly thereafter they stopped (I also unsubscribed their email
address that was mirroring the list to make sure!) The reason I did
this is I don't want to expose your email addresses to the anonymous
public any more than necessary. The request-confirmation subscription
method to the list helps prevent spammers from subscribing, but the
digest is visible on the WWW so people can see your addresses, so
this list isn't really private, though it exposes you a lot less to
spammers than usenet. Even though the findmail web interface was
intriguing and would give the list good exposure, I didn't think I
could in good conscience allow it without making that clear to
you, the list members, in advance. Some of you might not want our
discussions made more public than they are already. As far as I am
concerned that is the end of it. I'll keep an eye out for other
"subscribers" that are really automatic list mirrors.

Finally, in my opinion xmission is a capable list host despite
occasional problems. Everybody should know that xmission is providing
this list for free, and it does cost them effort and resources. I am
not even an xmission user, so they don't owe me anything. W all owe
them thanks!

If you have responses to anything I've written here, PLEASE don't
post it to the list. If you think there are non-fractal issues we
should discuss here, propose it to me privately and I'll entertain
the proposal. But once again, since there's so much list traffic,
let's keep list administration discussion off the list except for
these occasional messages from me to let know know what is happening.

Thanks, and happy fractal discussions!

Tim Wegner






- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

Date: Fri, 23 Jan 1998 19:48:24 -0700 (MST)
From: Kerry Mitchell <[e-mail]>
Subject: (fractint) Explanation, parameters, & formulas--range (long)

comment { ; narrative copyright Kerry Mitchell

Range

In the range coloring schemes, the pixels of the Julia set images
are only colored when the iterate (of a component of it) falls within
a specified range.  This is similar to the bubble method, which only
treats orbits that pass close to the origin.  With an appropriate
choice of parameters, the range schemes can be forced to generate
bubbles-type images.  However, the intent of the range method was
to render Julia sets through thin rings of color, using a relatively
small range of magnitudes in which to trap the orbit.

The simplest case is shown in the range-r formulas.  Here, the orbit
is monitored until the magnitude of the iterate falls within a
specified range.  When this occurs, that iterate is saved.  Upon
bailout (either escape or maximum iterations), the last iterate
falling within the range is recalled, and its polar angle shown via
decomposition coloring.  Depending on the range chosen, the results
can be circular rings, pinched loops (figure "8"), or open loops.
The shapes are definitely non-fractal, but are assembled in such a
way to recover the underlying fractal structure.

Choosing the range is very important, as a greatly impacts the image.
The most direct route is to simply specify the upper and lower bounds
of the range.  This is the method used in range-r, and can require a
great deal of thought, to coordinate a range with the Julia parameter.
The other formulas using this method adust the ranges depending on the
Julia parameter c.  The range parameters are set by the user, the
center and the width.  For example, choosing a center of 1.0 and a
width of 0.1 means that the range will extend from 0.95 to 1.05, half
the width either side of the center.  The value of the center depends
on the the formula chosen.  In range-r-1, the basis for the range is
|c|, so the above choices would result in a range from 95% |c| to
105% |c|.  This basis was chosen since c is the first iterate of 0
(0^2 + c = c), and zero is the critical point of z^2 + c.  Another
way of looking at it is that, by choosing a range centered around c,
the orbit of 0 will fall into the range on the first iteration.  The
formulas range-r-2 and -3 use the second and third iterations,
respectively, so their bases are |sqr(c)+c| and |sqr(sqr(c)+c)+c|.

This method opens itself up to many variations.  For example, instead
of monitoring the magnitude of the iterate, the real or imaginary
components can be tracked.  The formulas range-x and range-y perform
this.  In range-x, the real part of the iterate is watched.  When it
falls into the target range, the imaginary part of the iterate is
scaled and used as the decomposition angle.  Range-y does the same
thing, switching the roles of the real and imaginary parts.  Each is
offered with the 4 above range setting options:  explicit, c, sqr(c)+c,
sqr(sqr(c)+c)+c (the formulas are named similar to the range-r entries,
substituting -x or -y as appropriate).

Each of the above formulas uses the last occurance of an iterate inside
the target range to color the pixel.  If the orbit is such that the
range is hit many times, that prior information is lost.  One manner to
recover part of that information is with the rangecount formulas.  The
basic setup is the same as the range formulas, but now the decomposition
angle is the count of how many times the orbit landed in the range.  A
scale factor is available to convert the count into a useable angle.
This method seems to work especially well when the range width is
increased, to increase the hit count and make more colors available.

}

range-r-1-sample   { ; copyright Kerry Mitchell
;
; sample parameter file for range-r-1_jul
;
  reset=1960 type=formula formulafile=fractint.frm
  formulaname=range-r-1_jul passes=1 center-mag=0/0/0.85
  params=-0.778/0.201/4/0/1/0.05 float=y maxiter=256 inside=0
  colors=000<11>z00<3>zA0<6>zi0zo0xq2vt4tw6qz9<11>0zz<10>0Uz0\
  Rz0Px0Nu0Ls0Ip<3>0BW<3>100<9>p00v00z00<2>z80zB0zG0<4>ze0zk0\
  zo0<2>sw7pzAlzE<10>0zz<11>0Rz<2>0Kr0Io0Gj0Fe0D_0BU08M05E036\
  200<9>r00w00z10z30z60z80zC0<5>zg0zl0yp1ws3uu5sx7ozB<9>7zs3z\
  w0yz<10>0Tz0Qy0Ow0Mt0Kr0In0Gi0Ec0CZ<3>024300<10>x00z10z40z6\
  0z90zD0<5>zh0zm0yq1ws3tv6ry8<10>6zt2zx0xz<11>0Qy0Ov0Lt0Jq0H\
  m0Fg0Eb0CY<3>012 cyclerange=0/255 decomp=256 periodicity=0
  }

range-r-2-sample   { ; copyright Kerry Mitchell
;
; sample parameter file for range-r-2_jul
;
  reset=1960 type=formula formulafile=fractint.frm
  formulaname=range-r-2_jul passes=1 center-mag=0/0/0.85
  params=-0.778/0.201/4/0/1/0.125 float=y maxiter=256 inside=0
  colors=000<11>z00<3>zA0<6>zi0zo0xq2vt4tw6qz9<11>0zz<10>0Uz0R\
  z0Px0Nu0Ls0Ip<3>0BW<3>100<9>p00v00z00<2>z80zB0zG0<4>ze0zk0zo\
  0<2>sw7pzAlzE<10>0zz<11>0Rz<2>0Kr0Io0Gj0Fe0D_0BU08M05E036200\
  <9>r00w00z10z30z60z80zC0<5>zg0zl0yp1ws3uu5sx7ozB<9>7zs3zw0yz\
  <10>0Tz0Qy0Ow0Mt0Kr0In0Gi0Ec0CZ<3>024300<10>x00z10z40z60z90z\
  D0<5>zh0zm0yq1ws3tv6ry8<10>6zt2zx0xz<11>0Qy0Ov0Lt0Jq0Hm0Fg0E\
  b0CY<3>012 cyclerange=0/255 decomp=256 periodicity=0
  }

range-x-1-sample   { ; copyright Kerry Mitchell
;
; sample parameter file for range-x-1_jul
;
  reset=1960 type=formula formulafile=fractint.frm
  formulaname=range-x-1_jul passes=1 center-mag=0/0/1.2/1/90
  params=0.28/0.005/4/64/2/0.02 float=y maxiter=256 inside=0
  decomp=256 periodicity=0
  colors=000<35>x00z00z10<34>zx0zz0zz1<36>zzz<51>zz2zz0zy0<5\
  1>y20x00w00<30>200000000000000 cyclerange=0/255
  }

range-y-2-sample   { ; copyright Kerry Mitchell
;
; sample parameter file for range-y-2_jul
;
  reset=1960 type=formula formulafile=fractint.frm
  formulaname=range-y-2_jul passes=1 center-mag=0/0/1.2/1/90
  params=0.28/0.005/4/64/3/0.3 float=y maxiter=2000 inside=0
  decomp=256 periodicity=0
  colors=000<40>x00z00z00<40>zy0zz0zz1<39>zzxzzzzzz<40>1zz0z\
  z0yz<39>02z00z00z<41>000 cyclerange=0/255
  }

third-time's...    { ; copyright Kerry Mitchell
;
; sample parameter file for range-r-3_jul
;
  reset=1960 type=formula formulafile=fractint.frm
  formulaname=range-r-3_jul passes=1 center-mag=0/0/0.9/1/-10
  params=-0.0573720519293145/0.6691939992424446/4/0/3/0.333333
  float=y maxiter=3000 inside=0 decomp=256 periodicity=0
  colors=000<22>00w00z01z<4>07z08z0Az0Cz<13>0lz0oz1py<5>7xs9zq\
  Bzo<21>wz3zz0zy0<21>zT0zR0yQ0xP0<4>rK0pI0nI0<5>ZC0WB0SA0<6>0\
  01<20>00s00v00x00z<4>06z08z09z0Bz0Dz<11>0hz0kz0mz0oz<6>8yrAz\
  pCzn<21>xz2zz0zx0<22>zR0yQ0wP0<2>tL0rK0qJ0oI0mH0<4>_D0YC0UB0\
  <6>210 cyclerange=0/255
  }

threex             { ; copyright Kerry Mitchell
;
; sample parameter file for range-x-3_jul
;
  reset=1960 type=formula formulafile=fractint.frm
  formulaname=range-x-3_jul passes=1 center-mag=0/0/0.8
  params=-0.1/1/1000/1/1/1 float=y maxiter=256 inside=0
  decomp=256 periodicity=0 cyclerange=0/255
  colors=00610A20C30F<2>61K71M81N91O<10>K6_L7`M8`<4>RCdSCeTDfUE\
  fVFgWGh<9>eSnfTogUphWpiXqjZq<7>rjvslvtnwupwvqx<2>ywyzyzzyz<8>\
  qiupguoetndtmbslar<7>dQncPmbOlaNl`Mk<7>TDfSCeRCd<4>M8`L7`K6_J\
  6ZI5YH5X<7>91O81N71M61K50I40H30F20C10A00610820B30E<4>81M91OA2\
  PB2Q<3>F3UG4WH4W<4>M7`N8aO9bPAbQAc<11>`MlaNlbPmcQmdRn<6>k`rla\
  smcsnet<8>wtyxvyyxzzzzyxzxvy<11>lask`rjZriYqhXp<2>eSodRncQmbP\
  maNl<15>N8aM7`L7_K6ZJ6YI5XH4WG4W<6>91O81M71L61J50I40G<2>108000
  }

threey             { ; copyright Kerry Mitchell
;
; sample parameter file for range-y-3_jul
;
  reset=1960 type=formula formulafile=fractint.frm passes=1
  center-mag=-0.339487/0.595596/11.21076 params=-0.1/1/64/1/0.5/1
  float=y maxiter=256 inside=0 decomp=256 periodicity=0
  colors=N`p<10>RftSftSgtTgtThu<3>VjvVjvWkvXkw<14>dsyesyftygtyhuz\
  <3>kwzlwznxzoxz<2>tzzzzztzzryz<4>kwzjvzivzhuzhuzgty<8>`px`ox_ox\
  _nxZnx<5>WkvVjvVjvViv<12>PcrObqObqOapNap<20>GSfFRfFReFQd<13>AJX\
  AJWAIVAIU9HU<33>001000001<31>9GS9HT9HUAIUAIVAJW<25>IVjJWkJWkKXl\
  KXl<6>M`o cyclerange=0/255 formulaname=range-y-3_jul
  }

frm:range-r_jul { ; Kerry Mitchell
        ;
        ; colors Julia set only when magnitude of iterate
        ; falls in certain range; range explicity specified
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = unused
        ; real(p3) = lower bound of range (try 0.05)
        ; imag(p3) = upper bound of range (try 0.06)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), iter=1, z=1
        lo=real(p3), hi=imag(p3):
        ;
        ; iteration
        ;   if magnitude of iterate falls into range, save iterate
        ;
        iter=iter+1, zc=sqr(zc)+c, r=|zc|
        if ((r>lo)&&(r<hi))
          z=zc
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     iterate was within range
        ;   if iterate was never in range, z was initially set to 1
        ;     so decomp with use color 0
        ;
        if ((r>maxr)||(iter==maxit))
          iter=-1
          end if
        iter>0
        }

frm:range-r-1_jul { ; Kerry Mitchell
        ;
        ; colors Julia set only when magnitude of iterate
        ; falls in certain range; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = unused
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by |c|
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), iter=1
        z=1, fac=|c|
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac:
        ;
        ; iteration
        ;   if magnitude of iterate falls into range, save iterate
        ;
        iter=iter+1, zc=sqr(zc)+c, r=|zc|
        if ((r>lo)&&(r<hi))
          z=zc
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     iterate was within range
        ;   if iterate was never in range, z was initially set to 1
        ;     so decomp with use color 0
        ;
        if ((r>maxr)||(iter==maxit))
          iter=-1
          end if
        iter>0
        }

frm:range-r-2_jul { ; Kerry Mitchell
        ;
        ; colors Julia set only when magnitude of iterate
        ; falls in certain range; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = unused
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by |sqr(c)+c|
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), iter=1
        z=1, fac=|sqr(c)+c|
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac:
        ;
        ; iteration
        ;   if magnitude of iterate falls into range, save iterate
        ;
        iter=iter+1, zc=sqr(zc)+c, r=|zc|
        if ((r>lo)&&(r<hi))
          z=zc
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     iterate was within range
        ;   if iterate was never in range, z was initially set to 1
        ;     so decomp with use color 0
        ;
        if ((r>maxr)||(iter==maxit))
          iter=-1
          end if
        iter>0
        }

frm:range-r-3_jul { ; Kerry Mitchell
        ;
        ; colors Julia set only when magnitude of iterate
        ; falls in certain range; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = unused
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by |sqr(sqr(c)+c)+c|
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), iter=1
        z=1, fac=|sqr(sqr(c)+c)+c|
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac:
        ;
        ; iteration
        ;   if magnitude of iterate falls into range, save iterate
        ;
        iter=iter+1, zc=sqr(zc)+c, r=|zc|
        if ((r>lo)&&(r<hi))
          z=zc
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     iterate was within range
        ;   if iterate was never in range, z was initially set to 1
        ;     so decomp with use color 0
        ;
        if ((r>maxr)||(iter==maxit))
          iter=-1
          end if
        iter>0
        }

frm:range-x_jul { ; Kerry Mitchell
        ;
        ; colors Julia set by imaginary part of iterate, only
        ; when real part of iterate falls in certain range;
        ; range specified explicitly
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 16)
        ; real(p3) = lower end of range (try 0.05)
        ; imag(p3) = upper end of range (try 0.06)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2)
        iter=1, angle=0, lo=real(p3), hi=imag(p3):
        ;
        ; iteration
        ;   if real part of iterate falls into range,
        ;   scale imaginary part into decomp angle
        ;
        iter=iter+1, zc=sqr(zc)+c, r=real(zc)
        if ((r>lo)&&(r<hi))
          angle=scale*imag(zc)
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     real part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:range-x-1_jul { ; Kerry Mitchell
        ;
        ; colors Julia set by imaginary part of iterate, only
        ; when real part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 16)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by real(c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        angle=0, fac=real(c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if real part of iterate falls into range,
        ;   scale imaginary part into decomp angle
        ;
        iter=iter+1, zc=sqr(zc)+c, r=real(zc)
        if ((r>lo)&&(r<hi))
          angle=scale*imag(zc)
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     real part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:range-x-2_jul { ; Kerry Mitchell
        ;
        ; colors Julia set by imaginary part of iterate, only
        ; when real part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 16)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by real(sqr(c)+c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        angle=0, fac=real(sqr(c)+c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if real part of iterate falls into range,
        ;   scale imaginary part into decomp angle
        ;
        iter=iter+1, zc=sqr(zc)+c, r=real(zc)
        if ((r>lo)&&(r<hi))
          angle=scale*imag(zc)
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     real part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:range-x-3_jul { ; Kerry Mitchell
        ;
        ; colors Julia set by imaginary part of iterate, only
        ; when real part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 16)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by real(sqr(sqr(c)+c)+c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        angle=0, fac=real(sqr(sqr(c)+c)+c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if real part of iterate falls into range,
        ;   scale imaginary part into decomp angle
        ;
        iter=iter+1, zc=sqr(zc)+c, r=real(zc)
        if ((r>lo)&&(r<hi))
          angle=scale*imag(zc)
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     real part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:range-y_jul { ; Kerry Mitchell
        ;
        ; colors Julia set by real part of iterate, only
        ; when imaginary part of iterate falls in certain range;
        ; range specified explicitly
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 16)
        ; real(p3) = lower end of range (try 0.05)
        ; imag(p3) = upper end of range (try 0.06)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2)
        iter=1, angle=0, lo=real(p3), hi=imag(p3):
        ;
        ; iteration
        ;   if imaginary part of iterate falls into range,
        ;   scale real part into decomp angle
        ;
        iter=iter+1, zc=sqr(zc)+c, r=imag(zc)
        if ((r>lo)&&(r<hi))
          angle=scale*real(zc)
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     imaginary part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:range-y-1_jul { ; Kerry Mitchell
        ;
        ; colors Julia set by real part of iterate, only when
        ; imaginary part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 16)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by imag(c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        angle=0, fac=imag(c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if imaginary part of iterate falls into range,
        ;   scale real part into decomp angle
        ;
        iter=iter+1, zc=sqr(zc)+c, r=imag(zc)
        if ((r>lo)&&(r<hi))
          angle=scale*real(zc)
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     imaginary part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:range-y-2_jul { ; Kerry Mitchell
        ;
        ; colors Julia set by real part of iterate, only when
        ; imaginary part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 16)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by imag(sqr(c)+c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        angle=0, fac=imag(sqr(c)+c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if imaginary part of iterate falls into range,
        ;   scale real part into decomp angle
        ;
        iter=iter+1, zc=sqr(zc)+c, r=imag(zc)
        if ((r>lo)&&(r<hi))
          angle=scale*real(zc)
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     imaginary part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:range-y-3_jul { ; Kerry Mitchell
        ;
        ; colors Julia set by real part of iterate, only when
        ; imaginary part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 16)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by imag(sqr(sqr(c)+c)+c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        angle=0, fac=imag(sqr(sqr(c)+c)+c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if imaginary part of iterate falls into range,
        ;   scale real part into decomp angle
        ;
        iter=iter+1, zc=sqr(zc)+c, r=imag(zc)
        if ((r>lo)&&(r<hi))
          angle=scale*real(zc)
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to last time
        ;     imaginary part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-r_jul { ; Kerry Mitchell
        ;
        ; colors Julia set only when magnitude of iterate
        ; falls in certain range; range explicity specified
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = lower bound of range (try 0.05)
        ; imag(p3) = upper bound of range (try 0.06)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2)
        iter=1, count=0, lo=real(p3), hi=imag(p3):
        ;
        ; iteration
        ;   if magnitude of iterate falls into range,
        ;     increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=|zc|
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times iterate was within range
        ;   if iterate was never in range, z was initially set to 1
        ;     so decomp with use color 0
        ;
        if ((r>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-r-1_jul { ; Kerry Mitchell
        ;
        ; colors Julia set only when magnitude of iterate
        ; falls in certain range; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by |c|
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2)
        iter=1, count=0, fac=|c|
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac:
        ;
        ; iteration
        ;   if magnitude of iterate falls into range,
        ;     increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=|zc|
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times iterate was within range
        ;   if iterate was never in range, z was initially set to 1
        ;     so decomp with use color 0
        ;
        if ((r>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-r-2_jul { ; Kerry Mitchell
        ;
        ; colors Julia set only when magnitude of iterate
        ; falls in certain range; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by |sqr(c)+c|
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2)
        iter=1, count=0, fac=|sqr(c)+c|
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac:
        ;
        ; iteration
        ;   if magnitude of iterate falls into range,
        ;     increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=|zc|
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times iterate was within range
        ;   if iterate was never in range, z was initially set to 1
        ;     so decomp with use color 0
        ;
        if ((r>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-r-3_jul { ; Kerry Mitchell
        ;
        ; colors Julia set only when magnitude of iterate
        ; falls in certain range; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by |sqr(sqr(c)+c)+c|
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2)
        iter=1, count=0, fac=|sqr(sqr(c)+c)+c|
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac:
        ;
        ; iteration
        ;   if magnitude of iterate falls into range,
        ;     increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=|zc|
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times iterate was within range
        ;   if iterate was never in range, z was initially set to 1
        ;     so decomp with use color 0
        ;
        if ((r>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-x_jul { ; Kerry Mitchell
        ;
        ; colors Julia set according to how many times real
        ; part of iterate falls in certain range;
        ; range specified explicitly
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = lower end of range (try 0.05)
        ; imag(p3) = upper end of range (try 0.06)
        ; center of range is multiplied by real(c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2)
        iter=1, count=0, lo=real(p3), hi=imag(p3):
        ;
        ; iteration
        ;   if real part of iterate falls into range,
        ;   increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=real(zc)
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times real part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-x-1_jul { ; Kerry Mitchell
        ;
        ; colors Julia set according to how many times real
        ; part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by real(c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        count=0, fac=real(c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if real part of iterate falls into range,
        ;   increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=real(zc)
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times real part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-x-2_jul { ; Kerry Mitchell
        ;
        ; colors Julia set according to how many times real
        ; part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by real(sqr(c)+c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        count=0, fac=real(sqr(c)+c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if real part of iterate falls into range,
        ;   increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=real(zc)
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times real part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-x-3_jul { ; Kerry Mitchell
        ;
        ; colors Julia set according to how many times real
        ; part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by real(sqr(sqr(c)+c)+c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        count=0, fac=real(sqr(sqr(c)+c)+c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if real part of iterate falls into range,
        ;   increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=real(zc)
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times real part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-y_jul { ; Kerry Mitchell
        ;
        ; colors Julia set according to how many times imaginary
        ; part of iterate falls in certain range;
        ; range specified explicitly
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = lower end of range (try 0.05)
        ; imag(p3) = upper end of range (try 0.1)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2)
        iter=1, count=0, lo=real(p3), hi=imag(p3):
        ;
        ; iteration
        ;   if imaginary part of iterate falls into range,
        ;   increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=imag(zc)
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times imaginary part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-y-1_jul { ; Kerry Mitchell
        ;
        ; colors Julia set according to how many times imaginary
        ; part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by imag(c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        count=0, fac=imag(c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if imaginary part of iterate falls into range,
        ;   increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=imag(zc)
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times imaginary part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-y-2_jul { ; Kerry Mitchell
        ;
        ; colors Julia set according to how many times imaginary
        ; part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by imag(sqr(c)+c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        count=0, fac=imag(sqr(c)+c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if imaginary part of iterate falls into range,
        ;   increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=imag(zc)
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times imaginary part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

frm:rangecount-y-3_jul { ; Kerry Mitchell
        ;
        ; colors Julia set according to how many times imaginary
        ; part of iterate falls in certain range;
        ; range specified in terms of c
        ; use decomp=256
        ;
        ; p1 = Julia parameter
        ; real(p2) = bailout (try 4)
        ; imag(p2) = decomposition scale factor (try 1)
        ; real(p3) = center of range (try 1)
        ; imag(p3) = width of range (try 0.1)
        ; center of range is multiplied by imag(sqr(sqr(c)+c)+c)
        ; calculation done on variable zc, z used for coloring
        ;
        zc=pixel, c=p1, maxr=real(p2), scale=imag(p2), iter=1
        count=0, fac=imag(sqr(sqr(c)+c)+c)
        lo=(real(p3)-imag(p3)/2)*fac, hi=(real(p3)+imag(p3)/2)*fac
        if (hi<lo)
          temp=lo, lo=hi, hi=temp
          end if
        :
        ;
        ; iteration
        ;   if imaginary part of iterate falls into range,
        ;   increment counter
        ;
        iter=iter+1, zc=sqr(zc)+c, r=imag(zc)
        if ((r>lo)&&(r<hi))
          count=count+1
          end if
        ;
        ; bailout--escape and maximum iterations treated the same
        ;   set "iteration done" flag (iter=-1)
        ;   decomposition method will color according to how many
        ;     times imaginary part of iterate was within range
        ;   if iterate was never in range, angle was initially set
        ;     to 0, so decomp with use color 0
        ;
        if ((|zc|>maxr)||(iter==maxit))
          iter=-1
          angle=scale*count
          z=cos(angle)+flip(sin(angle))
          end if
        iter>0
        }

- -------------------------------------------------------------------------------
Kerry Mitchell
[e-mail]
- -------------------------------------------------------------------------------


- -
- ------------------------------------------------------------
Thanks for using Fractint, The Fractals and Fractint Discussion List
Post Message:   [e-mail]
Get Commands:   [e-mail] "help"
Administrator:  [e-mail]
Unsubscribe:    [e-mail] "unsubscribe fractint"

------------------------------

End of fractint-digest V1 #88
*****************************