2
This iteration of FRACTINT.FRM was first released with Fractint 19.0
4
The formulas at the beginning of this file are from Mark Peterson, who
5
built this fractal interpreter feature. The rest are grouped by contributor.
6
Formulas by unidentified authors are grouped at the end.
8
If you would like to contribute formulas for future versions of this file,
9
please contact one of the authors listed in FRACTINT.DOC.
10
All contributions are assumed to belong to the public domain.
12
There are several hard-coded restrictions in the formula interpreter:
14
1) The fractal name through the open curly bracket must be on a single line.
15
2) There is a hard-coded limit of 2000 formulas per formula file, only
16
because of restrictions in the prompting routines.
17
3) Formulas can contain at most 2000 operations (references to variables and
18
arithmetic); this is bigger than it sounds.
19
4) Comment blocks can be set up using dummy formulas with no formula name
20
or with the special name "comment".
22
Note that the builtin "cos" function had a bug which was corrected in
23
version 16. To recreate an image from a formula which used cos before
24
v16, change "cos" in the formula to "cosxx" which is a new function
25
provided for backward compatibility with that bug.
28
{--- MARK PETERSON -------------------------------------------------------}
30
Mandelbrot(XAXIS) {; Mark Peterson
31
; Classical fractal showing LastSqr speedup
32
z = Pixel, z = Sqr(z): ; Start with z**2 to initialize LastSqr
35
LastSqr <= 4 ; Use LastSqr instead of recalculating
38
Dragon (ORIGIN) {; Mark Peterson
40
z = sqr(z) + (-0.74543, 0.2)
44
Daisy (ORIGIN) {; Mark Peterson
46
z = z*z + (0.11031, -0.67037)
50
InvMandel (XAXIS) {; Mark Peterson
56
DeltaLog(XAXIS) {; Mark Peterson
57
z = pixel, c = log(pixel):
62
Newton4(XYAXIS) {; Mark Peterson
63
; Note that floating-point is required to make this compute accurately
67
z = (3 * z4 + Root) / (4 * z3)
71
{--- DON ARCHER ----------------------------------------------------------}
73
DAFRM01 {; Don Archer, 1993
75
z = z ^ (z - 1) * (fn1(z) + pixel)
81
z = z ^ (z - 1) * fn1(z) + pixel
86
z = pixel, c = z + z^ (z - 1):
88
real(tmp) = real(tmp) * real(c) - imag(tmp) * imag(c)
89
imag(tmp) = real(tmp) * imag(c) - imag(tmp) * real(c)
96
x = real(z), y = imag(z)
97
x1 = -fn1((x*x*x + y*y*y - 1) - 6*x)*x/(2*x*x*x + y*y*y - 1)
98
y1 = -fn2((x*x*x + y*y*y - 1) + 6*x)*y/(2*x*x*x + y*y*y - 1)
99
x2 = x1*x1*x1 - y1*y1*y1 + p1 + 5
105
3daMand01 {; Mandelbrot/Zexpe via Lee Skinner
106
; based on 4dFRACT.FRM by Gordon Lamb (CIS: 100272,3541)
107
z=real(pixel)+flip(imag(pixel)*p1)
108
c=p2+p1*real(pixel)+flip(imag(pixel)):
109
z=z^2.71828182845905 + c
113
3daMand02 {; Mandelbrot/Xexpe/Feigenbaum's alpha constant=exponent
114
; based on 4dFRACT.FRM by Gordon Lamb (CIS: 100272,3541)
115
z=real(pixel)+flip(imag(pixel)*p1)
116
c=p2+p1*real(pixel)+flip(imag(pixel)):
117
z=z^2.502907875095 + c
121
{--- RON BARNETT ---------------------------------------------------------}
123
Julike { ; Ron Barnett, 1993
124
; a Julia function based upon the Ikenaga function
126
z = z*z*z + (P1-1)*z - P1
130
Mask { ; Ron Barnett, 1993
131
; try fn1 = log, fn2 = sinh, fn3 = cosh
132
;P1 = (0,1), P2 = (0,1)
135
z = P1*fn2(z)^2 + P2*fn3(z)^2 + pixel
139
JMask { ; Ron Barnett, 1993
145
PseudoZeePi {; Ron Barnett, 1993
148
z = z*((1-x)/(1+x))^(1/p1) + p2
152
ZeePi { ; Ron Barnett, 1993
153
; This Julia function is based upon Ramanujan's iterative
154
; function for calculating pi
157
z = z*(1-x)/(1+x) + p2
161
IkeNewtMand {; Ron Barnett, 1993
163
zf = z*z*z + (c-1)*z - c
169
Frame-RbtM(XAXIS) {; Ron Barnett, 1993
170
; from Mazes for the Mind by Pickover
172
z = z*z*z/5 + z*z + c
176
FrRbtGenM {; Ron Barnett, 1993
178
z = p1*z*z*z + z*z + pixel
182
FlipLambdaJ { ; Ron Barnett, 1993
184
z = p1*z*(1-flip(z)*flip(z))
188
REBRefInd2 { ; Ron Barnett, 1993
191
z = (z*z-1)/(z*z+2)*fn1(z)*fn2(z) + p1
197
x = real(z), y = imag(z)
206
REB004A {; Ron Barnett, 1993
208
z =p1*fn1(z) + p1*p1*fn2(p2*z) + pixel
212
REB004K {; Ron Barnett, 1993
213
; floating point required
215
x = flip(pixel + fn1(3/z - z/4))
220
REB004L {; Ron Barnett, 1993
221
; floating point required
223
x = flip(pixel + fn1(p1/z - z/(p2+1)))
228
REB004M {; Ron Barnett, 1993
229
; floating point required
231
x = real(z), y = imag(z)
233
x1 = -fn1(const - 12*x)*x/(4*const)
234
y1 = -fn2(const + 12*x)*y/(4*const)
235
x2 = x1*x1 - y1*y1 + p1
241
REB005A {; Ron Barnett, 1993
242
; floating point required
244
x = real(z), y = imag(z)
246
x1 = -fn1(const - 12*x)*x/(4*const)
247
y1 = -fn2(const + 12*y)*y/(4*const)
248
x2 = x1*x1 - y1*y1 + p1
254
REB005E {; Ron Barnett, 1993
255
; floating point required
257
x = real(z), y = imag(z)
259
x1 = -fn1((const - x)*x/const)
260
y1 = -fn2((const + y)*y/const)
261
x2 = x1*x1 - y1*y1 + p1
267
REB005F {; Ron Barnett, 1993
268
; floating point required
270
x = real(z), y = imag(z)
272
x1 = -fn1((const - 12*x)*x/(4*const))
273
y1 = -fn2((const + 12*y)*y/(4*const))
274
x2 = x1*x1 - y1*y1 + p1
280
REB005G {; Ron Barnett, 1993
281
; floating point required
283
x = real(z), y = imag(z)
285
x1 = -fn1(const + p1*x)*y/const
286
y1 = -fn2(const + y)*x/const
287
x2 = x1*x1 - y1*y1 + p2
293
{--- BRADLEY BEACHAM -----------------------------------------------------}
295
OK-01 { ;TRY P1 REAL = 10000, FN1 = SQR
302
OK-04 { ;TRY FN2 = SQR, DIFFERENT FUNCTIONS FOR FN1
303
z = 0, c = fn1(pixel):
309
z = pixel, c = fn1(pixel):
316
z = pixel, c = fn1(pixel):
328
OK-36 { ; DISSECTED MANDELBROT
329
; TO GENERATE "STANDARD" MANDELBROT, SET P1 = 0,0 & ALL FN = IDENT
330
z = pixel, cx = fn1(real(z)), cy = fn2(imag(z)), k = 2 + p1:
331
zx = real(z), zy = imag(z)
332
x = fn3(zx*zx - zy*zy) + cx
333
y = fn4(k * zx * zy) + cy
338
OK-38 { ; DISSECTED CUBIC MANDELBROT
339
; TO GENERATE "STANDARD" CUBIC MANDELBROT, SET P1 = 0,0 & ALL FN = IDENT
340
z = pixel, cx = fn1(real(pixel)), cy = fn2(imag(pixel)), k = 3 + p1:
341
zx = real(z), zy = imag(z)
342
x = fn3(zx*zx*zx - k*zx*zy*zy) + cx
343
y = fn4(k*zx*zx*zy - zy*zy*zy) + cy
348
OK-42 { ; MUTATION OF FN + FN
349
z = pixel, p1x = real(p1)+1, p1y = imag(p1)+1
350
p2x = real(p2)+1, p2y = imag(p2)+1:
351
zx = real(z), zy = imag(z)
352
x = fn1(zx*p1x - zy*p1y) + fn2(zx*p2x - zy*p2y)
353
y = fn3(zx*p1y + zy*p1x) + fn4(zx*p2y + zy*p2x)
358
OK-43 { ; DISSECTED SPIDER
359
; TO GENERATE "STANDARD" SPIDER, SET P1 = 0,0 & ALL FN = IDENT
360
z = c = pixel, k = 2 + p1:
361
zx = real(z), zy = imag(z)
362
cx = real(c), cy = imag(c)
363
x = fn1(zx*zx - zy*zy) + cx
364
y = fn2(k*zx*zy) + cy
366
c = fn3((cx + flip(cy))/k) + z
370
{--- PIETER BRANDERHORST -------------------------------------------------}
373
The following resulted from a FRACTINT bug. Version 13 incorrectly
374
calculated Spider (see above). We fixed the bug, and reverse-engineered
375
what it was doing to Spider - so here is the old "spider"
378
Wineglass(XAXIS) {; Pieter Branderhorst
381
c = (1+flip(imag(c))) * real(c) / 2 + z
385
{--- JM COLLARD-RICHARD --------------------------------------------------}
388
These are the original "Richard" types sent by Jm Collard-Richard. Their
389
generalizations are tacked on to the end of the "Jm" list below, but
390
we felt we should keep these around for historical reasons.
393
Richard1 (XYAXIS) {; Jm Collard-Richard
395
sq=z*z, z=(sq*sin(sq)+sq)+pixel
399
Richard2 (XYAXIS) {; Jm Collard-Richard
401
z=1/(sin(z*z+pixel*pixel))
405
Richard3 (XAXIS) {; Jm Collard-Richard
407
sh=sinh(z), z=(1/(sh*sh))+pixel
411
Richard4 (XAXIS) {; Jm Collard-Richard
413
z2=z*z, z=(1/(z2*cos(z2)+z2))+pixel
417
Richard5 (XAXIS) {; Jm Collard-Richard
419
z=sin(z*sinh(z))+pixel
423
Richard6 (XYAXIS) {; Jm Collard-Richard
429
Richard7 (XAXIS) {; Jm Collard-Richard
435
Richard8 (XYAXIS) {; Jm Collard-Richard
436
; This was used for the "Fractal Creations" cover
437
z=pixel,sinp = sin(pixel):
442
Richard9 (XAXIS) {; Jm Collard-Richard
444
sqrz=z*z, z=sqrz + 1/sqrz + pixel
448
Richard10(XYAXIS) {; Jm Collard-Richard
454
Richard11(XYAXIS) {; Jm Collard-Richard
461
These types are generalizations of types sent to us by the French
462
mathematician Jm Collard-Richard. If we hadn't generalized them
463
there would be --ahhh-- quite a few. With 26 possible values for
464
each fn variable, Jm_03, for example, has 456,976 variations!
467
Jm_01 {; generalized Jm Collard-Richard type
469
z=(fn1(fn2(z^pixel)))*pixel
473
Jm_02 {; generalized Jm Collard-Richard type
475
z=(z^pixel)*fn1(z^pixel)
479
Jm_03 {; generalized Jm Collard-Richard type
481
z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))*pixel
485
Jm_03a {; generalized Jm Collard-Richard type
487
z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))+pixel
491
Jm_04 {; generalized Jm Collard-Richard type
493
z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))
497
Jm_05 {; generalized Jm Collard-Richard type
499
z=fn1(fn2((z^pixel)))
503
Jm_06 {; generalized Jm Collard-Richard type
505
z=fn1(fn2(fn3((z^z)*pixel)))
509
Jm_07 {; generalized Jm Collard-Richard type
511
z=fn1(fn2(fn3((z^z)*pixel)))*pixel
515
Jm_08 {; generalized Jm Collard-Richard type
517
z=fn1(fn2(fn3((z^z)*pixel)))+pixel
521
Jm_09 {; generalized Jm Collard-Richard type
523
z=fn1(fn2(fn3(fn4(z))))+pixel
527
Jm_10 {; generalized Jm Collard-Richard type
529
z=fn1(fn2(fn3(fn4(z)*pixel)))
533
Jm_11 {; generalized Jm Collard-Richard type
535
z=fn1(fn2(fn3(fn4(z)*pixel)))*pixel
539
Jm_11a {; generalized Jm Collard-Richard type
541
z=fn1(fn2(fn3(fn4(z)*pixel)))+pixel
545
Jm_12 {; generalized Jm Collard-Richard type
547
z=fn1(fn2(fn3(z)*pixel))
551
Jm_13 {; generalized Jm Collard-Richard type
553
z=fn1(fn2(fn3(z)*pixel))*pixel
557
Jm_14 {; generalized Jm Collard-Richard type
559
z=fn1(fn2(fn3(z)*pixel))+pixel
563
Jm_15 {; generalized Jm Collard-Richard type
565
f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))*pixel
569
Jm_16 {; generalized Jm Collard-Richard type
571
f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))+pixel
575
Jm_17 {; generalized Jm Collard-Richard type
577
z=fn1(z)*pixel*fn2(fn3(z))
581
Jm_18 {; generalized Jm Collard-Richard type
583
z=fn1(z)*pixel*fn2(fn3(z)*pixel)
587
Jm_19 {; generalized Jm Collard-Richard type
589
z=fn1(z)*pixel*fn2(fn3(z)+pixel)
593
Jm_20 {; generalized Jm Collard-Richard type
599
Jm_21 {; generalized Jm Collard-Richard type
605
Jm_22 {; generalized Jm Collard-Richard type
607
sq=fn1(z), z=(sq*fn2(sq)+sq)+pixel
611
Jm_23 {; generalized Jm Collard-Richard type
613
z=fn1(fn2(fn3(z)+pixel*pixel))
617
Jm_24 {; generalized Jm Collard-Richard type
619
z2=fn1(z), z=(fn2(z2*fn3(z2)+z2))+pixel
623
Jm_25 {; generalized Jm Collard-Richard type
625
z=fn1(z*fn2(z)) + pixel
629
Jm_26 {; generalized Jm Collard-Richard type
631
z=fn1(fn2(z)) + pixel
635
Jm_27 {; generalized Jm Collard-Richard type
637
sqrz=fn1(z), z=sqrz + 1/sqrz + pixel
641
Jm_ducks(XAXIS) {; Jm Collard-Richard
642
; Not so ugly at first glance and lot of corners to zoom in.
643
; try this: corners=-1.178372/-0.978384/-0.751678/-0.601683
644
z=pixel,tst=p1+4,t=1+pixel:
649
Gamma(XAXIS) { ; first order gamma function from Prof. Jm
650
; "It's pretty long to generate even on a 486-33 comp but there's a lot
651
; of corners to zoom in and zoom and zoom...beautiful pictures :)"
652
z=pixel,twopi=6.283185307179586,r=10:
653
z=(twopi*z)^(0.5)*(z^z)*exp(-z)+pixel
657
ZZ(XAXIS) { ; Prof Jm using Newton-Raphson method
658
; use floating point with this one
663
0.001 <= |solution-z1|
666
ZZa(XAXIS) { ; Prof Jm using Newton-Raphson method
667
; use floating point with this one
670
z2=(((z-1)/z)+log(z))*z1
672
.001 <= |solution-z1|
675
GenInvMand1_N { ; Jm Collard-Richard
677
z=fn1(z)*fn2(z)+fn3(fn4(c))
681
{--- W. LEROY DAVIS ------------------------------------------------------}
684
These are from: "AKA MrWizard W. LeRoy Davis;SM-ALC/HRUC"
685
davisl@sm-logdis1-aflc.af.mil
686
The first 3 are variations of:
688
gamma(z) = (z/e) * sqrt(2*pi*z) * R
691
Sterling(XAXIS) {; davisl
693
z = ((z/2.7182818)^z)/sqr(6.2831853*z)
697
Sterling2(XAXIS) {; davisl
699
z = ((z/2.7182818)^z)/sqr(6.2831853*z) + pixel
703
Sterling3(XAXIS) {; davisl
705
z = ((z/2.7182818)^z)/sqr(6.2831853*z) - pixel
709
PsudoMandel(XAXIS) {; davisl - try center=0,0/magnification=28
711
z = ((z/2.7182818)^z)*sqr(6.2831853*z) + pixel
715
{--- ROB DEN BRAASEM -----------------------------------------------------}
725
z = c*z*(z*z*(z*z*(z*z-7)+14)-7)
731
z = c*(z*z*(z*z-3)+1)
737
z = c*(z*z*(z*z*(z*z-5)+6)-1)
743
z = c*z*(z*z*(z*z*(z*z-6)+10)-4)
749
z = (z*(z - 4) +2 ) / 2 + c
755
z = (z*(z*(-z + 9) -18) + 6 ) / 6 + c
761
z = (z*z*(35 * z*z - 30) + 3) / 8 + c
767
z = c*(z*(z*z*(16*z*z-20)+5))
773
z = c*z*(z*z*(z*z-5)+5)
791
z = (3 * z*z - 1) / 2 + c
797
z = (z*z*(z*z*(231 * z*z - 315) + 105 ) - 5) / 16 + c
801
{--- CHUCK EBBERT & JON HORNER -------------------------------------------}
804
Chaotic Liar formulas for FRACTINT. These formulas reproduce some of the
805
pictures in the paper 'Pattern and Chaos: New Images in the Semantics of
806
Paradox' by Gary Mar and Patrick Grim of the Department of Philosophy,
807
SUNY at Stony Brook. "...what is being graphed within the unit square is
808
simply information regarding the semantic behavior for different inputs
809
of a pair of English sentences:"
812
Liar1 { ; by Chuck Ebbert.
813
; X: X is as true as Y
814
; Y: Y is as true as X is false
815
; Calculate new x and y values simultaneously.
816
; y(n+1)=abs((1-x(n) )-y(n) ), x(n+1)=1-abs(y(n)-x(n) )
818
z = 1 - abs(imag(z)-real(z) ) + flip(1 - abs(1-real(z)-imag(z) ) )
822
Liar3 { ; by Chuck Ebbert.
823
; X: X is true to P1 times the extent that Y is true
824
; Y: Y is true to the extent that X is false.
825
; Sequential reasoning. P1 usually 0 to 1. P1=1 is Liar2 formula.
826
; x(n+1) = 1 - abs(p1*y(n)-x(n) );
827
; y(n+1) = 1 - abs((1-x(n+1) )-y(n) );
829
x = 1 - abs(imag(z)*real(p1)-real(z) )
830
z = flip(1 - abs(1-real(x)-imag(z) ) ) + real(x)
834
Liar4 { ; by Chuck Ebbert.
835
; X: X is as true as (p1+1) times Y
836
; Y: Y is as true as X is false
837
; Calculate new x and y values simultaneously.
838
; Real part of p1 changes probability. Use floating point.
839
; y(n+1)=abs((1-x(n) )-y(n) ), x(n+1)=1-abs(y(n)-x(n) )
840
z = pixel, p = p1 + 1:
841
z = 1-abs(imag(z)*p-real(z))+flip(1-abs(1-real(z)-imag(z)))
845
F'Liar1 { ; Generalization by Jon Horner of Chuck Ebbert formula.
846
; X: X is as true as Y
847
; Y: Y is as true as X is false
848
; Calculate new x and y values simultaneously.
849
; y(n+1)=abs((1-x(n) )-y(n) ), x(n+1)=1-abs(y(n)-x(n) )
851
z = 1 - abs(imag(z)-real(z) ) + flip(1 - abs(1-real(z)-imag(z) ) )
855
M-SetInNewton(XAXIS) {; use float=yes
856
; jon horner 100112,1700, 12 feb 93
857
z = 0, c = pixel, cminusone = c-1:
858
oldz = z, nm = 3*c-2*z*cminusone, dn = 3*(3*z*z+cminusone)
863
F'M-SetInNewtonA(XAXIS) {; use float=yes
864
; jon horner 100112,1700, 12 feb 93
865
z = 0, c = fn1(pixel), cminusone = c-1:
866
oldz = z, nm = p1*c-2*z*cminusone, dn = p1*(3*z*z+cminusone)
871
F'M-SetInNewtonC(XAXIS) { ; same as F'M-SetInNewtonB except for bailout
872
; use float=yes, periodicity=no
873
; (3 <= p1 <= ?) and (1e-30 < p2 < .01)
874
z=0, c=fn1(pixel), cm1=c-1, cm1x2=cm1*2, twoop1=2/p1, p1xc=c*real(p1):
875
z = (p1xc - z*cm1x2 )/( (sqr(z)*3 + cm1 ) * real(p1) ) + z*real(twoop1)
876
abs(|z| - real(lastsqr) ) >= p2
879
{--- SYLVIE GALLET -------------------------------------------------------}
882
This formula uses Newton's formula applied to the real equation :
883
F(x,y) = 0 where F(x,y) = (x^3 + y^2 - 1 , y^3 - x^2 + 1)
884
starting with (x_0,y_0) = z0 = pixel
886
(x_(n+1),y_(n+1)) = (x_n,y_n) - (F'(x_n,y_n))^-1 * F(x_n,y_n)
887
where (F'(x_n,y_n))^-1 is the inverse of the Jacobian matrix of F.
890
Newton_real { ; Sylvie Gallet [101324,3444], 1996
891
; Newton's method applied to x^3 + y^2 - 1 = 0
894
; One parameter : real(p1) = bailout value
895
z = pixel , x = real(z) , y = imag(z) :
897
d = 9*xy+4 , x2 = x*x , y2 = y*y
899
x1 = x*c - (y*y2 - 3*y - 2)/x
900
y1 = y*c + (x*x2 + 2 - 3*x)/y
901
z = (x1+flip(y1))/d , x = real(z) , y = imag(z)
902
(|x| >= p1) || (|y+1| >= p1)
905
G-3-03-M { ; Sylvie Gallet [101324,3444], 1996
906
; Modified Gallet-3-03 formula
908
x = real(z) , y = imag(z)
909
x1 = x - p1 * fn1(y*y + round(p2*fn2(y)))
910
y1 = y - p1 * fn1(x*x + round(p2*fn2(x)))
915
{--- CHRIS GREEN ---------------------------------------------------------}
918
These fractals all use Newton's or Halley's formula for approximation of
919
a function. In all of these fractals, p1 real is the "relaxation
920
coefficient". A value of 1 gives the conventional newton or halley
921
iteration. Values <1 will generally produce less chaos than values >1.
922
1-1.5 is probably a good range to try. P1 imag is the imaginary
923
component of the relaxation coefficient, and should be zero but maybe a
924
small non-zero value will produce something interesting. Who knows?
925
For more information on Halley maps, see "Computers, Pattern, Chaos, and
929
Halley (XYAXIS) {; Chris Green. Halley's formula applied to x^7-x=0.
930
; P1 real usually 1 to 1.5, P1 imag usually zero. Use floating point.
931
; Setting P1 to 1 creates the picture on page 277 of Pickover's book
936
z=z-p1*((z7-z)/ ((7.0*z6-1)-(42.0*z5)*(z7-z)/(14.0*z6-2)))
940
CGhalley (XYAXIS) {; Chris Green -- Halley's formula
941
; P1 real usually 1 to 1.5, P1 imag usually zero. Use floating point.
946
z=z-p1*((z7-z-pixel)/ ((7.0*z6-1)-(42.0*z5)*(z7-z-pixel)/(14.0*z6-2)))
947
0.0001 <= |z7-z-pixel|
950
halleySin (XYAXIS) {; Chris Green. Halley's formula applied to sin(x)=0.
951
; Use floating point.
952
; P1 real = 0.1 will create the picture from page 281 of Pickover's book.
955
z=z-p1*(s/(c-(s*s)/(c+c)))
959
NewtonSinExp (XAXIS) {; Chris Green
960
; Newton's formula applied to sin(x)+exp(x)-1=0.
961
; Use floating point.
965
z=z-p1*z2/(cos(z)+z1)
969
CGNewtonSinExp (XAXIS) {
973
z=z-p1*z2/(cos(z)+z1)
977
CGNewton3 {; Chris Green -- A variation on newton iteration.
978
; The initial guess is fixed at (1,1), but the equation solved
979
; is different at each pixel ( x^3-pixel=0 is solved).
980
; Use floating point.
985
z=z-p1*(z3-pixel)/(3.0*z2)
989
HyperMandel {; Chris Green.
990
; A four dimensional version of the mandelbrot set.
991
; Use P1 to select which two-dimensional plane of the
992
; four dimensional set you wish to examine.
993
; Use floating point.
996
anew=sqr(a)-sqr(b)+pixel
1002
OldHalleySin (XYAXIS) {
1006
z=z-p1*(s/(c-(s*s)/(c+c)))
1010
{--- RICHARD HUGHES ------------------------------------------------------}
1012
phoenix_m { ; Mandelbrot style map of the Phoenix curves
1013
z=x=y=nx=ny=x1=y1=x2=y2=0:
1014
x2 = sqr(x), y2 = sqr(y)
1015
x1 = x2 - y2 + real(pixel) + imag(pixel) * nx
1016
y1 = 2 * x * y + imag(pixel) * ny
1017
nx=x, ny=y, x=x1, y=y1, z=x + flip(y)
1021
{--- GORDON LAMB ---------------------------------------------------------}
1023
SJMAND01 {;Mandelbrot
1024
z=real(pixel)+flip(imag(pixel)*p1)
1025
c=p2+p1*real(pixel)+flip(imag(pixel)):
1030
3RDIM01 {;Mandelbrot
1031
z=p1*real(pixel)+flip(imag(pixel))
1032
c=p2+real(pixel)+flip(imag(pixel)*p1):
1037
SJMAND03 {;Mandelbrot function
1038
z=real(pixel)+p1*(flip(imag(pixel)))
1039
c=p2+p1*real(pixel)+flip(imag(pixel)):
1044
SJMAND05 {;Mandelbrot lambda function
1045
z=real(pixel)+flip(imag(pixel)*p1)
1046
c=p2+p1*real(pixel)+flip(imag(pixel)):
1051
3RDIM05 {;Mandelbrot lambda function
1052
z=p1*real(pixel)+flip(imag(pixel))
1053
c=p2+real(pixel)+flip(imag(pixel)*p1):
1058
SJMAND10 {;Mandelbrot power function
1059
z=real(pixel),c=p2+flip(imag(pixel)):
1064
SJMAND11 {;Mandelbrot lambda function - lower bailout
1065
z=real(pixel)+flip(imag(pixel)*p1)
1066
c=p2+p1*real(pixel)+flip(imag(pixel)):
1071
{--- KEVIN LEE -----------------------------------------------------------}
1073
LeeMandel1(XYAXIS) {; Kevin Lee
1075
;; c=sqr(pixel)/z, c=z+c, z=sqr(z), this line was an error in v16
1076
c=sqr(pixel)/z, c=z+c, z=sqr(c)
1080
LeeMandel2(XYAXIS) {; Kevin Lee
1082
c=sqr(pixel)/z, c=z+c, z=sqr(c*pixel)
1086
LeeMandel3(XAXIS) {; Kevin Lee
1087
z=Pixel, c=Pixel-sqr(z):
1088
c=Pixel+c/z, z=c-z*pixel
1092
{--- RON LEWEN -----------------------------------------------------------}
1094
RCL_Cross1 { ; Ron Lewen
1095
; Try p1=(0,1), fn1=sin and fn2=sqr. Set corners at
1096
; -10/10/-7.5/7.5 to see a cross shape. The larger
1097
; lakes at the center of the cross have good detail
1099
; Use floating point.
1105
RCL_Pick13 { ; Ron Lewen
1106
; Formula from Frontpiece for Appendix C
1107
; and Credits in Pickover's book.
1108
; Set p1=(3,0) to generate the Frontpiece
1109
; for Appendix C and to (2,0) for Credits
1110
; Use Floating Point
1116
RCL_1 (XAXIS) { ; Ron Lewen
1117
; An interesting Biomorph inspired by Pickover's
1118
; Computers, Pattern, Choas and Beauty.
1119
; Use Floating Point
1122
|real(z)| <= 100 || |imag(z)| <= 100
1125
RCL_Cosh (XAXIS) { ; Ron Lewen, 76376,2567
1126
; Try corners=2.008874/-3.811126/-3.980167/3.779833/
1127
; -3.811126/3.779833 to see Figure 9.7 (P. 123) in
1128
; Pickover's Computers, Pattern, Chaos and Beauty.
1129
; Figures 9.9 - 9.13 can be found by zooming.
1130
; Use floating point
1136
Mothra (XAXIS) { ; Ron Lewen, 76376,2567
1137
; Remember Mothra, the giant Japanese-eating moth?
1138
; Well... here he (she?) is as a fractal!
1140
a=z^5 + z^3 + z + pixel
1143
|real(z)| <= 100 || |imag(z)| <= 100
1146
RCL_10 { ; Ron Lewen, 76376,2567
1148
z=flip((z^2+pixel)/(pixel^2+z))
1152
{--- LEE SKINNER ---------------------------------------------------------}
1154
MTet (XAXIS) {; Mandelbrot form 1 of the Tetration formula --Lee Skinner
1156
z = (pixel ^ z) + pixel
1160
AltMTet(XAXIS) {; Mandelbrot form 2 of the Tetration formula --Lee Skinner
1162
z = (pixel ^ z) + pixel
1166
JTet (XAXIS) {; Julia form 1 of the Tetration formula --Lee Skinner
1168
z = (pixel ^ z) + P1
1172
AltJTet (XAXIS) {; Julia form 2 of the Tetration formula --Lee Skinner
1174
z = (pixel ^ z) + P1
1178
Cubic (XYAXIS) {; Lee Skinner
1179
p = pixel, test = p1 + 3
1181
a = (t2 + 1)/t3, b = 2*a*a*a + (t2 - 2)/t3
1182
aa3 = a*a*3, z = 0 - a :
1183
z = z*z*z - aa3*z + b
1187
Fzppfnre {; Lee Skinner
1188
z = pixel, f = 1./(pixel):
1193
Fzppfnpo {; Lee Skinner
1194
z = pixel, f = (pixel)^(pixel):
1199
Fzppfnsr {; Lee Skinner
1200
z = pixel, f = (pixel)^.5:
1205
Fzppfnta {; Lee Skinner
1206
z = pixel, f = tan(pixel):
1211
Fzppfnct {; Lee Skinner
1212
z = pixel, f = cos(pixel)/sin(pixel):
1217
Fzppfnse {; Lee Skinner
1218
z = pixel, f = 1./sin(pixel):
1223
Fzppfncs {; Lee Skinner
1224
z = pixel, f = 1./cos(pixel):
1229
Fzppfnth {; Lee Skinner
1230
z = pixel, f = tanh(pixel):
1235
Fzppfnht {; Lee Skinner
1236
z = pixel, f = cosh(pixel)/sinh(pixel):
1241
Fzpfnseh {; Lee Skinner
1242
z = pixel, f = 1./sinh(pixel):
1247
Fzpfncoh {; Lee Skinner
1248
z = pixel, f = 1./cosh(pixel):
1254
s = exp(1.,0.), z = Pixel:
1260
s = log(-1.,0.) / (0.,1.) is (3.14159265358979, 0.0)
1264
s = log(-1.,0.) / (0.,1.), z = Pixel:
1270
z = pixel, f = cosxx (pixel):
1276
z = pixel, f = sqr (pixel):
1282
z = pixel, f = (pixel) ^ 0.5:
1288
s = exp(1.,0.), z = Pixel, f = Pixel ^ s:
1293
OldManowar (XAXIS) {
1305
z = pixel, TEST = (p1+3):
1311
z = pixel, TEST = (p1+3):
1312
z = (z*cosxx(z)) - z
1316
TSinh (XAXIS) {; Tetrated Hyperbolic Sine - Improper Bailout
1317
z = c = sinh(pixel):
1322
{--- SCOTT TAYLOR --------------------------------------------------------}
1325
The following is from Scott Taylor.
1326
Scott says they're "Dog" because the first one he looked at reminded him
1327
of a hot dog. This was originally several fractals, we have generalized it.
1330
FnDog(XYAXIS) {; Scott Taylor
1331
z = Pixel, b = p1+2:
1332
z = fn1( z ) * pixel
1337
; Try params=.5/.75 and the first function as exp.
1338
; Zoom in on the swirls around the middle. There's a
1339
; symmetrical area surrounded by an asymmetric area.
1340
z = Pixel, y = fn1(z), base = log(p1):
1345
Ent2 {; Scott Taylor
1346
; try params=2/1, functions=cos/cosh, potential=255/355
1347
z = Pixel, y = fn1(z), base = log(p1):
1348
z = fn2( y * log(z) / base )
1352
{--- MICHAEL THEROUX & RON BARNETT ---------------------------------------}
1354
test3 {; Michael Theroux [71673,2767]
1355
;fix and generalization by Ron Barnett [70153,1233]
1357
;try p1 = 2.236067977 for the golden mean
1358
z = ((p1 + 1)/2)/pixel:
1359
z = z*z + pixel*((p1 + 1)/2)/((p1 - 1)/2)
1363
{--- TIMOTHY WEGNER ------------------------------------------------------}
1365
Newton_poly2 { ; Tim Wegner - use float=yes
1366
; fractal generated by Newton formula z^3 + (c-1)z - c
1367
; p1 is c in above formula
1368
z = pixel, z2 = z*z, z3 = z*z2:
1369
z = (2*z3 + p1) / (3*z2 + (p1 - 1))
1372
.004 <= |z3 + (p1-1)*z - p1|
1375
Newt_ellipt_oops { ; Tim Wegner - use float=yes and periodicity=0
1376
; fractal generated by Newton formula (z^3 + c*z^2 +1)^.5
1377
; try p1 = 1 and p2 = .1
1378
; if p2 is small (say .001), converges very slowly so need large maxit
1379
; another "tim's error" - mistook sqr for sqrt (see next)
1380
z = pixel, z2 = z*z, z3 = z*z2:
1381
num = (z3 + p1*z2 + 1)^.5 ; f(z)
1382
denom = (1.5*z2 + p1*z)/num ; f'(z)
1383
z = z - (num/denom) ; z - f(z)/f'(z)
1386
p2 <= |z3 + p1*z2 + 1| ; no need for sqrt because sqrt(z)==0 iff z==0
1389
Newton_elliptic { ; Tim Wegner - use float=yes and periodicity=0
1390
; fractal generated by Newton formula f(z) = (z^3 + c*z^2 +1)^2
1391
; try p1 = 1 and p2 = .0001
1392
z = pixel, z2 = z*z, z3 = z*z2:
1393
z = z - (z3 + p1*z2 + 1)/(6*z2 + 4*p1*z) ; z - f(z)/f'(z)
1396
p2 <= |z3 + p1*z2 + 1| ; no need for sqr because sqr(z)==0 iff z==0
1399
{--- TIM WEGNER & MARK PETERSON ------------------------------------------}
1402
These are a few of the examples from the book, Fractal Creations, by Tim
1403
Wegner and Mark Peterson.
1406
MyFractal {; Fractal Creations example
1412
MandelTangent {; Fractal Creations example (revised for v.16)
1418
Mandel3 {; Fractal Creations example
1419
z = pixel, c = sin(z):
1425
{--- AUTHORS UNKNOWN -----------------------------------------------------}
1434
Bali {;The difference of two squares
1435
z=x=1/pixel, c= fn1 (z):
1442
z=x=1/pixel, c= fn1 (z):
1450
z =(1/((z^(real(p1)))*(c^(real(p2))))*c) + c
1455
z = fn1(1/(z+p1))*fn2(z+p1)
1460
z = Pixel, c = fn1(pixel):
1461
z = fn2(1/(z+c))*fn3(z+c)
1467
z = fn1(p1+z)*fn2(p2-z)
added
removed
fractint.frm
