home *** CD-ROM | disk | FTP | other *** search
/ Hot Shareware 32 / hot34.iso / ficheros / DGRAF / FRAIN196.ZIP / FRACTINT.FRM < prev    next >
Text File  |  1997-05-04  |  35KB  |  1,470 lines
  1. comment {
  2.  This iteration of FRACTINT.FRM was first released with Fractint 19.0
  3.  
  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.
  7.  
  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.
  11.  
  12.  There are several hard-coded restrictions in the formula interpreter:
  13.  
  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".
  21.  
  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.
  26.  }
  27.  
  28. {--- MARK PETERSON -------------------------------------------------------}
  29.  
  30. Mandelbrot(XAXIS) {; Mark Peterson
  31.   ; Classical fractal showing LastSqr speedup
  32.   z = Pixel, z = Sqr(z):  ; Start with z**2 to initialize LastSqr
  33.    z = z + Pixel
  34.    z = Sqr(z)
  35.     LastSqr <= 4      ; Use LastSqr instead of recalculating
  36.   }
  37.  
  38. Dragon (ORIGIN) {; Mark Peterson
  39.   z = Pixel:
  40.    z = sqr(z) + (-0.74543, 0.2)
  41.     |z| <= 4
  42.   }
  43.  
  44. Daisy (ORIGIN) {; Mark Peterson
  45.   z = pixel:
  46.    z = z*z + (0.11031, -0.67037)
  47.     |z| <= 4
  48.   }
  49.  
  50. InvMandel (XAXIS) {; Mark Peterson
  51.   c = z = 1 / pixel:
  52.    z = sqr(z) + c
  53.     |z| <= 4
  54.   }
  55.  
  56. DeltaLog(XAXIS) {; Mark Peterson
  57.   z = pixel, c = log(pixel):
  58.    z = sqr(z) + c
  59.     |z| <= 4
  60.   }
  61.  
  62. Newton4(XYAXIS) {; Mark Peterson
  63.   ; Note that floating-point is required to make this compute accurately
  64.   z = pixel, Root = 1:
  65.    z3 = z*z*z
  66.    z4 = z3 * z
  67.    z = (3 * z4 + Root) / (4 * z3)
  68.     .004 <= |z4 - Root|
  69.   }
  70.  
  71. {--- DON ARCHER ----------------------------------------------------------}
  72.  
  73. DAFRM01 {;  Don Archer, 1993
  74.   z = pixel :
  75.    z = z ^ (z - 1) * (fn1(z) + pixel)
  76.     |z| <= 4
  77.   }
  78.  
  79. DAFRM07 {
  80.   z = pixel, c = p1 :
  81.    z = z ^ (z - 1) * fn1(z) + pixel
  82.     |z| <= 4
  83.   }
  84.  
  85. DAFRM09 {
  86.   z = pixel, c = z + z^ (z - 1):
  87.    tmp = fn1(z)
  88.    real(tmp) = real(tmp) * real(c) - imag(tmp) * imag(c)
  89.    imag(tmp) = real(tmp) * imag(c) - imag(tmp) * real(c)
  90.    z = tmp + pixel + 12
  91.     |z| <= 4
  92.   }
  93.  
  94. dafrm21 {
  95.   z = pixel:
  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
  100.    y2 = 4*x*y - 18
  101.    z = x2 + flip(y2)
  102.     |z| <= 100
  103.   }
  104.  
  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
  110.     |z|<=100
  111.   }
  112.  
  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
  118.     |z|<=100
  119.   }
  120.  
  121. {--- RON BARNETT ---------------------------------------------------------}
  122.  
  123. Julike { ; Ron Barnett, 1993
  124.   ; a Julia function based upon the Ikenaga function
  125.   z = Pixel:
  126.    z = z*z*z + (P1-1)*z - P1
  127.     |z| <= 4
  128.   }
  129.  
  130. Mask { ; Ron Barnett, 1993
  131.   ; try fn1 = log, fn2 = sinh, fn3 = cosh
  132.   ;P1 = (0,1), P2 = (0,1)
  133.   ;Use floating point
  134.   z = fn1(pixel):
  135.    z = P1*fn2(z)^2 + P2*fn3(z)^2 + pixel
  136.     |z| <= 4
  137.   }
  138.  
  139. JMask {  ; Ron Barnett, 1993
  140.   z = fn1(pixel):
  141.    z = P1*fn2(z)^2 + P2
  142.     |z| <= 4
  143.   }
  144.  
  145. PseudoZeePi {; Ron Barnett, 1993
  146.   z = pixel:
  147.    x = 1-z^p1;
  148.    z = z*((1-x)/(1+x))^(1/p1) + p2
  149.     |z| <= 4
  150.   }
  151.  
  152. ZeePi {  ; Ron Barnett, 1993
  153.   ; This Julia function is based upon Ramanujan's iterative
  154.   ; function for calculating pi
  155.   z = pixel:
  156.    x = (1-z^p1)^(1/p1)
  157.    z = z*(1-x)/(1+x) + p2
  158.     |z| <= 4
  159.   }
  160.  
  161. IkeNewtMand {; Ron Barnett, 1993
  162.   z = c = pixel:
  163.    zf = z*z*z + (c-1)*z - c
  164.    zd = 3*z*z + c-1
  165.    z = z - p1*zf/zd
  166.     0.001 <= |zf|
  167.   }
  168.  
  169. Frame-RbtM(XAXIS) {; Ron Barnett, 1993
  170.   ; from Mazes for the Mind by Pickover
  171.   z = c = pixel:
  172.    z = z*z*z/5 + z*z + c
  173.     |z| <= 100
  174.   }
  175.  
  176. FrRbtGenM {; Ron Barnett, 1993
  177.   z = pixel:
  178.    z = p1*z*z*z + z*z + pixel
  179.     |z| <= 100
  180.   }
  181.  
  182. FlipLambdaJ { ; Ron Barnett, 1993
  183.   z = pixel:
  184.    z = p1*z*(1-flip(z)*flip(z))
  185.     |z| <= 100
  186.   }
  187.  
  188. REBRefInd2 {  ; Ron Barnett, 1993
  189.   ; Use floating point
  190.   z = pixel:
  191.    z = (z*z-1)/(z*z+2)*fn1(z)*fn2(z) + p1
  192.     |z| <= 100
  193.   }
  194.  
  195. GopalsamyFn {
  196.   z = pixel:
  197.    x = real(z), y = imag(z)
  198.    x1 = fn1(x)*fn2(y)
  199.    y1 = fn3(x)*fn4(y)
  200.    x2 = -2*x1*y1 + p1
  201.    y = y1*y1 - x1*x1
  202.    z = x2 + flip(y)
  203.     |z| <= 100
  204.   }
  205.  
  206. REB004A {; Ron Barnett, 1993
  207.   z = pixel:
  208.    z =p1*fn1(z) + p1*p1*fn2(p2*z) + pixel
  209.     |z| <= 100
  210.   }
  211.  
  212. REB004K {; Ron Barnett, 1993
  213.   ; floating point required
  214.   z = pixel:
  215.    x = flip(pixel + fn1(3/z - z/4))
  216.    z = x*z + p1
  217.     |z| <= 100
  218.   }
  219.  
  220. REB004L {; Ron Barnett, 1993
  221.   ; floating point required
  222.   z = pixel:
  223.    x = flip(pixel + fn1(p1/z - z/(p2+1)))
  224.    z = x*z + pixel
  225.     |z| <= 100
  226.   }
  227.  
  228. REB004M {; Ron Barnett, 1993
  229.   ; floating point required
  230.   z = pixel:
  231.    x = real(z), y = imag(z)
  232.    const = x*x + y*y
  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
  236.    y2 = 2*x*y
  237.    z = x2 + flip(y2)
  238.     |z| <= 100
  239.   }
  240.  
  241. REB005A {; Ron Barnett, 1993
  242.   ; floating point required
  243.   z = pixel:
  244.    x = real(z), y = imag(z)
  245.    const = x*x + y*y
  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
  249.    y2 = 2*x1*y1
  250.    z = x2 + flip(y2)
  251.     |z| <= 100
  252.   }
  253.  
  254. REB005E {; Ron Barnett, 1993
  255.   ; floating point required
  256.   z = pixel:
  257.    x = real(z), y = imag(z)
  258.    const = x*x + y*y
  259.    x1 = -fn1((const - x)*x/const)
  260.    y1 = -fn2((const + y)*y/const)
  261.    x2 = x1*x1 - y1*y1 + p1
  262.    y2 = 2*x1*y1
  263.    z = x2 + flip(y2)
  264.     |z| <= 100
  265.   }
  266.  
  267. REB005F {; Ron Barnett, 1993
  268.   ; floating point required
  269.   z = pixel:
  270.    x = real(z), y = imag(z)
  271.    const = x*x + y*y
  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
  275.    y2 = 2*x1*y1
  276.    z = x2 + flip(y2)
  277.     |z| <= 100
  278.   }
  279.  
  280. REB005G {; Ron Barnett, 1993
  281.   ; floating point required
  282.   z = pixel:
  283.    x = real(z), y = imag(z)
  284.    const = x*x + y*y
  285.    x1 = -fn1(const + p1*x)*y/const
  286.    y1 = -fn2(const + y)*x/const
  287.    x2 = x1*x1 - y1*y1 + p2
  288.    y2 = 2*x1*y1
  289.    z = x2 + flip(y2)
  290.     |z| <= 100
  291.   }
  292.  
  293. {--- BRADLEY BEACHAM -----------------------------------------------------}
  294.  
  295. OK-01 { ;TRY P1 REAL = 10000, FN1 = SQR
  296.   z = 0, c = pixel:
  297.    z = (c^z) + c
  298.    z = fn1(z)
  299.     |z| <= (5 + p1)
  300.   }
  301.  
  302. OK-04 { ;TRY FN2 = SQR, DIFFERENT FUNCTIONS FOR FN1
  303.   z = 0, c = fn1(pixel):
  304.    z = fn2(z) + c
  305.     |z| <= (5 + p1)
  306.   }
  307.  
  308. OK-08 {
  309.   z = pixel, c = fn1(pixel):
  310.    z = z^z / fn2(z)
  311.    z = c / z
  312.     |z| <= (5 + p1)
  313.   }
  314.  
  315. OK-21 {
  316.   z = pixel, c = fn1(pixel):
  317.    z = fn2(z) + c
  318.     fn3(z) <= p1
  319.   }
  320.  
  321. OK-22 {
  322.   z = v = pixel:
  323.    v = fn1(v) * fn2(z)
  324.    z = fn1(z) / fn2(v)
  325.     |z| <= (5 + p1)
  326.   }
  327.  
  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
  334.    z = x + flip(y)
  335.     |z| <  (10 + p2)
  336.   }
  337.  
  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
  344.    z =  x + flip(y)
  345.     |z| <  (4 + p2)
  346.   }
  347.  
  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)
  354.    z = x + flip(y)
  355.     |z| <= 20
  356.   }
  357.  
  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
  365.    z = x + flip(y)
  366.    c = fn3((cx + flip(cy))/k) + z
  367.     |z| <  (10 + p2)
  368.   }
  369.  
  370. {--- PIETER BRANDERHORST -------------------------------------------------}
  371.  
  372. comment {
  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"
  376.   }
  377.  
  378. Wineglass(XAXIS) {; Pieter Branderhorst
  379.   c = z = pixel:
  380.    z = z * z + c
  381.    c = (1+flip(imag(c))) * real(c) / 2 + z
  382.     |z| <= 4
  383.   }
  384.  
  385. {--- JM COLLARD-RICHARD --------------------------------------------------}
  386.  
  387. comment {
  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.
  391.   }
  392.  
  393. Richard1 (XYAXIS) {; Jm Collard-Richard
  394.   z = pixel:
  395.    sq=z*z, z=(sq*sin(sq)+sq)+pixel
  396.     |z|<=50
  397.   }
  398.  
  399. Richard2 (XYAXIS) {; Jm Collard-Richard
  400.   z = pixel:
  401.    z=1/(sin(z*z+pixel*pixel))
  402.     |z|<=50
  403.   }
  404.  
  405. Richard3 (XAXIS) {; Jm Collard-Richard
  406.   z = pixel:
  407.    sh=sinh(z), z=(1/(sh*sh))+pixel
  408.     |z|<=50
  409.   }
  410.  
  411. Richard4 (XAXIS) {; Jm Collard-Richard
  412.   z = pixel:
  413.    z2=z*z, z=(1/(z2*cos(z2)+z2))+pixel
  414.     |z|<=50
  415.   }
  416.  
  417. Richard5 (XAXIS) {; Jm Collard-Richard
  418.   z = pixel:
  419.    z=sin(z*sinh(z))+pixel
  420.     |z|<=50
  421.   }
  422.  
  423. Richard6 (XYAXIS) {; Jm Collard-Richard
  424.   z = pixel:
  425.    z=sin(sinh(z))+pixel
  426.     |z|<=50
  427.   }
  428.  
  429. Richard7 (XAXIS) {; Jm Collard-Richard
  430.   z=pixel:
  431.    z=log(z)*pixel
  432.     |z|<=50
  433.   }
  434.  
  435. Richard8 (XYAXIS) {; Jm Collard-Richard
  436.   ; This was used for the "Fractal Creations" cover
  437.   z=pixel,sinp = sin(pixel):
  438.    z=sin(z)+sinp
  439.     |z|<=50
  440.   }
  441.  
  442. Richard9 (XAXIS) {; Jm Collard-Richard
  443.   z=pixel:
  444.    sqrz=z*z, z=sqrz + 1/sqrz + pixel
  445.     |z|<=4
  446.   }
  447.  
  448. Richard10(XYAXIS) {; Jm Collard-Richard
  449.   z=pixel:
  450.    z=1/sin(1/(z*z))
  451.     |z|<=50
  452.   }
  453.  
  454. Richard11(XYAXIS) {; Jm Collard-Richard
  455.   z=pixel:
  456.    z=1/sinh(1/(z*z))
  457.     |z|<=50
  458.   }
  459.  
  460. comment {
  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!
  465.   }
  466.  
  467. Jm_01 {; generalized Jm Collard-Richard type
  468.   z=pixel,t=p1+4:
  469.    z=(fn1(fn2(z^pixel)))*pixel
  470.     |z|<=t
  471.   }
  472.  
  473. Jm_02 {; generalized Jm Collard-Richard type
  474.   z=pixel,t=p1+4:
  475.    z=(z^pixel)*fn1(z^pixel)
  476.     |z|<=t
  477.   }
  478.  
  479. Jm_03 {; generalized Jm Collard-Richard type
  480.   z=pixel,t=p1+4:
  481.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))*pixel
  482.     |z|<=t
  483.   }
  484.  
  485. Jm_03a {; generalized Jm Collard-Richard type
  486.   z=pixel,t=p1+4:
  487.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))+pixel
  488.     |z|<=t
  489.   }
  490.  
  491. Jm_04 {; generalized Jm Collard-Richard type
  492.   z=pixel,t=p1+4:
  493.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))
  494.     |z|<=t
  495.   }
  496.  
  497. Jm_05 {; generalized Jm Collard-Richard type
  498.   z=pixel,t=p1+4:
  499.    z=fn1(fn2((z^pixel)))
  500.     |z|<=t
  501.   }
  502.  
  503. Jm_06 {; generalized Jm Collard-Richard type
  504.   z=pixel,t=p1+4:
  505.    z=fn1(fn2(fn3((z^z)*pixel)))
  506.     |z|<=t
  507.   }
  508.  
  509. Jm_07 {; generalized Jm Collard-Richard type
  510.   z=pixel,t=p1+4:
  511.    z=fn1(fn2(fn3((z^z)*pixel)))*pixel
  512.     |z|<=t
  513.   }
  514.  
  515. Jm_08 {; generalized Jm Collard-Richard type
  516.   z=pixel,t=p1+4:
  517.    z=fn1(fn2(fn3((z^z)*pixel)))+pixel
  518.     |z|<=t
  519.   }
  520.  
  521. Jm_09 {; generalized Jm Collard-Richard type
  522.   z=pixel,t=p1+4:
  523.    z=fn1(fn2(fn3(fn4(z))))+pixel
  524.     |z|<=t
  525.   }
  526.  
  527. Jm_10 {; generalized Jm Collard-Richard type
  528.   z=pixel,t=p1+4:
  529.    z=fn1(fn2(fn3(fn4(z)*pixel)))
  530.     |z|<=t
  531.   }
  532.  
  533. Jm_11 {; generalized Jm Collard-Richard type
  534.   z=pixel,t=p1+4:
  535.    z=fn1(fn2(fn3(fn4(z)*pixel)))*pixel
  536.     |z|<=t
  537.   }
  538.  
  539. Jm_11a {; generalized Jm Collard-Richard type
  540.   z=pixel,t=p1+4:
  541.    z=fn1(fn2(fn3(fn4(z)*pixel)))+pixel
  542.     |z|<=t
  543.   }
  544.  
  545. Jm_12 {; generalized Jm Collard-Richard type
  546.   z=pixel,t=p1+4:
  547.    z=fn1(fn2(fn3(z)*pixel))
  548.     |z|<=t
  549.   }
  550.  
  551. Jm_13 {; generalized Jm Collard-Richard type
  552.   z=pixel,t=p1+4:
  553.    z=fn1(fn2(fn3(z)*pixel))*pixel
  554.     |z|<=t
  555.   }
  556.  
  557. Jm_14 {; generalized Jm Collard-Richard type
  558.   z=pixel,t=p1+4:
  559.    z=fn1(fn2(fn3(z)*pixel))+pixel
  560.     |z|<=t
  561.   }
  562.  
  563. Jm_15 {; generalized Jm Collard-Richard type
  564.   z=pixel,t=p1+4:
  565.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))*pixel
  566.     |z|<=t
  567.   }
  568.  
  569. Jm_16 {; generalized Jm Collard-Richard type
  570.   z=pixel,t=p1+4:
  571.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))+pixel
  572.     |z|<=t
  573.   }
  574.  
  575. Jm_17 {; generalized Jm Collard-Richard type
  576.   z=pixel,t=p1+4:
  577.    z=fn1(z)*pixel*fn2(fn3(z))
  578.     |z|<=t
  579.   }
  580.  
  581. Jm_18 {; generalized Jm Collard-Richard type
  582.   z=pixel,t=p1+4:
  583.    z=fn1(z)*pixel*fn2(fn3(z)*pixel)
  584.     |z|<=t
  585.   }
  586.  
  587. Jm_19 {; generalized Jm Collard-Richard type
  588.   z=pixel,t=p1+4:
  589.    z=fn1(z)*pixel*fn2(fn3(z)+pixel)
  590.     |z|<=t
  591.   }
  592.  
  593. Jm_20 {; generalized Jm Collard-Richard type
  594.   z=pixel,t=p1+4:
  595.    z=fn1(z^pixel)
  596.     |z|<=t
  597.   }
  598.  
  599. Jm_21 {; generalized Jm Collard-Richard type
  600.   z=pixel,t=p1+4:
  601.    z=fn1(z^pixel)*pixel
  602.     |z|<=t
  603.   }
  604.  
  605. Jm_22 {; generalized Jm Collard-Richard type
  606.   z=pixel,t=p1+4:
  607.    sq=fn1(z), z=(sq*fn2(sq)+sq)+pixel
  608.     |z|<=t
  609.   }
  610.  
  611. Jm_23 {; generalized Jm Collard-Richard type
  612.   z=pixel,t=p1+4:
  613.    z=fn1(fn2(fn3(z)+pixel*pixel))
  614.     |z|<=t
  615.   }
  616.  
  617. Jm_24 {; generalized Jm Collard-Richard type
  618.   z=pixel,t=p1+4:
  619.    z2=fn1(z), z=(fn2(z2*fn3(z2)+z2))+pixel
  620.     |z|<=t
  621.   }
  622.  
  623. Jm_25 {; generalized Jm Collard-Richard type
  624.   z=pixel,t=p1+4:
  625.    z=fn1(z*fn2(z)) + pixel
  626.     |z|<=t
  627.   }
  628.  
  629. Jm_26 {; generalized Jm Collard-Richard type
  630.   z=pixel,t=p1+4:
  631.    z=fn1(fn2(z)) + pixel
  632.     |z|<=t
  633.   }
  634.  
  635. Jm_27 {; generalized Jm Collard-Richard type
  636.   z=pixel,t=p1+4:
  637.    sqrz=fn1(z), z=sqrz + 1/sqrz + pixel
  638.     |z|<=t
  639.   }
  640.  
  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:
  645.    z=sqr(z)+t
  646.     |z|<=tst
  647.   }
  648.  
  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
  654.     |z|<=r
  655.   }
  656.  
  657. ZZ(XAXIS) { ; Prof Jm using Newton-Raphson method
  658.   ; use floating point with this one
  659.   z=pixel,solution=1:
  660.    z1=z^z
  661.    z2=(log(z)+1)*z1
  662.    z=z-(z1-1)/z2
  663.     0.001 <= |solution-z1|
  664.   }
  665.  
  666. ZZa(XAXIS) { ; Prof Jm using Newton-Raphson method
  667.   ; use floating point with this one
  668.   z=pixel,solution=1:
  669.    z1=z^(z-1)
  670.    z2=(((z-1)/z)+log(z))*z1
  671.    z=z-((z1-1)/z2)
  672.     .001 <= |solution-z1|
  673.   }
  674.  
  675. GenInvMand1_N { ; Jm Collard-Richard
  676.   c=z=1/pixel:
  677.    z=fn1(z)*fn2(z)+fn3(fn4(c))
  678.     |z|<=4
  679.   }
  680.  
  681. {--- W. LEROY DAVIS ------------------------------------------------------}
  682.  
  683. comment {
  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:
  687.          z
  688.      gamma(z) = (z/e) * sqrt(2*pi*z) * R
  689.   }
  690.  
  691. Sterling(XAXIS) {; davisl
  692.   z = Pixel:
  693.    z = ((z/2.7182818)^z)/sqr(6.2831853*z)
  694.     |z| <= 4
  695.   }
  696.  
  697. Sterling2(XAXIS) {; davisl
  698.   z = Pixel:
  699.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) + pixel
  700.     |z| <= 4
  701.   }
  702.  
  703. Sterling3(XAXIS) {; davisl
  704.   z = Pixel:
  705.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) - pixel
  706.     |z| <= 4
  707.   }
  708.  
  709. PsudoMandel(XAXIS) {; davisl - try center=0,0/magnification=28
  710.   z = Pixel:
  711.    z = ((z/2.7182818)^z)*sqr(6.2831853*z) + pixel
  712.     |z| <= 4
  713.   }
  714.  
  715. {--- ROB DEN BRAASEM -----------------------------------------------------}
  716.  
  717. J_TchebychevC3 {
  718.   c = pixel, z = P1:
  719.    z = c*z*(z*z-3)
  720.     |z|<100
  721.   }
  722.  
  723. J_TchebychevC7 {
  724.   c = pixel, z = P1:
  725.    z = c*z*(z*z*(z*z*(z*z-7)+14)-7)
  726.     |z|<100
  727.   }
  728.  
  729. J_TchebychevS4 {
  730.   c = pixel, z = P1:
  731.    z = c*(z*z*(z*z-3)+1)
  732.     |z|<100
  733.   }
  734.  
  735. J_TchebychevS6 {
  736.   c = pixel, z = P1:
  737.    z = c*(z*z*(z*z*(z*z-5)+6)-1)
  738.     |z|<100
  739.   }
  740.  
  741. J_TchebychevS7 {
  742.   c = pixel, z = P1:
  743.    z = c*z*(z*z*(z*z*(z*z-6)+10)-4)
  744.     |z|<100
  745.   }
  746.  
  747. J_Laguerre2 {
  748.   c = pixel, z = P1:
  749.    z = (z*(z - 4) +2 ) / 2 + c
  750.     |z| < 100
  751.   }
  752.  
  753. J_Laguerre3 {
  754.   c = pixel, z = P1:
  755.    z = (z*(z*(-z + 9) -18) + 6 ) / 6 + c
  756.     |z| < 100
  757.   }
  758.  
  759. J_Lagandre4 {
  760.   c = pixel, z = P1:
  761.    z = (z*z*(35 * z*z - 30) + 3) / 8 + c
  762.     |z| < 100
  763.   }
  764.  
  765. M_TchebychevT5 {
  766.   c = P1, z = Pixel:
  767.    z = c*(z*(z*z*(16*z*z-20)+5))
  768.     |z|<100
  769.   }
  770.  
  771. M_TchebychevC5 {
  772.   c = P1, z = Pixel:
  773.    z = c*z*(z*z*(z*z-5)+5)
  774.     |z|<100
  775.   }
  776.  
  777. M_TchebychevU3 {
  778.   c = P1, z = Pixel:
  779.    z = c*z*(8*z*z-4)
  780.     |z|<100
  781.   }
  782.  
  783. M_TchebychevS3 {
  784.   c = P1, z = Pixel:
  785.    z = c*z*(z*z-2)
  786.     |z|<100
  787.   }
  788.  
  789. M_Lagandre2 {
  790.   c = P1, z = Pixel:
  791.    z = (3 * z*z - 1) / 2 + c
  792.     |z| < 100
  793.   }
  794.  
  795. M_Lagandre6 {
  796.   c = P1, z = Pixel:
  797.    z = (z*z*(z*z*(231 * z*z - 315)  + 105 ) - 5) / 16 + c
  798.     |z| < 100
  799.   }
  800.  
  801. {--- CHUCK EBBERT & JON HORNER -------------------------------------------}
  802.  
  803. comment {
  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:"
  810.   }
  811.  
  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) )
  817.   z = pixel:
  818.    z = 1 - abs(imag(z)-real(z) ) + flip(1 - abs(1-real(z)-imag(z) ) )
  819.     |z| <= 1
  820.   }
  821.  
  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) );
  828.   z = pixel:
  829.    x = 1 - abs(imag(z)*real(p1)-real(z) )
  830.    z = flip(1 - abs(1-real(x)-imag(z) ) ) + real(x)
  831.     |z| <= 1
  832.   }
  833.  
  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)))
  842.     |z| <= 1
  843.   }
  844.  
  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) )
  850.   z = pixel:
  851.    z = 1 - abs(imag(z)-real(z) ) + flip(1 - abs(1-real(z)-imag(z) ) )
  852.     fn1(abs(z))<p1
  853.   }
  854.  
  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)
  859.    z = nm/dn+2*z/3
  860.     |(z-oldz)|>=|0.01|
  861.   }
  862.  
  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)
  867.    z = nm/dn+2*z/p1
  868.     |(z-oldz)|>=|0.01|
  869.   }
  870.  
  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
  877.   }
  878.  
  879. {--- SYLVIE GALLET -------------------------------------------------------}
  880.  
  881. comment {
  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
  885.   It calculates:
  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.
  888.   }
  889.  
  890. Newton_real { ; Sylvie Gallet [101324,3444], 1996
  891.   ; Newton's method applied to   x^3 + y^2 - 1 = 0
  892.   ;                              y^3 - x^2 + 1 = 0
  893.   ;                              solution (0,-1)
  894.   ; One parameter : real(p1) = bailout value
  895.   z = pixel , x = real(z) , y = imag(z) :
  896.    xy = x*y
  897.    d = 9*xy+4 , x2 = x*x , y2 = y*y
  898.    c = 6*xy+2
  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)
  903.   }
  904.  
  905. G-3-03-M  { ; Sylvie Gallet [101324,3444], 1996
  906.             ; Modified Gallet-3-03 formula
  907.   z = pixel :
  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)))
  911.    z = x1 + flip(y1)
  912.     |z| <= 4
  913.   }
  914.  
  915. {--- CHRIS GREEN ---------------------------------------------------------}
  916.  
  917. comment {
  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
  926.   Beauty" by Pickover.
  927.   }
  928.  
  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
  932.   z=pixel:
  933.    z5=z*z*z*z*z
  934.    z6=z*z5
  935.    z7=z*z6
  936.    z=z-p1*((z7-z)/ ((7.0*z6-1)-(42.0*z5)*(z7-z)/(14.0*z6-2)))
  937.     0.0001 <= |z7-z|
  938.   }
  939.  
  940. CGhalley (XYAXIS) {; Chris Green -- Halley's formula
  941.   ; P1 real usually 1 to 1.5, P1 imag usually zero. Use floating point.
  942.   z=(1,1):
  943.    z5=z*z*z*z*z
  944.    z6=z*z5
  945.    z7=z*z6
  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|
  948.   }
  949.  
  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.
  953.   z=pixel:
  954.    s=sin(z), c=cos(z)
  955.    z=z-p1*(s/(c-(s*s)/(c+c)))
  956.     0.0001 <= |s|
  957.   }
  958.  
  959. NewtonSinExp (XAXIS) {; Chris Green
  960.   ; Newton's formula applied to sin(x)+exp(x)-1=0.
  961.   ; Use floating point.
  962.   z=pixel:
  963.    z1=exp(z)
  964.    z2=sin(z)+z1-1
  965.    z=z-p1*z2/(cos(z)+z1)
  966.     .0001 < |z2|
  967.   }
  968.  
  969. CGNewtonSinExp (XAXIS) {
  970.   z=pixel:
  971.    z1=exp(z)
  972.    z2=sin(z)+z1-z
  973.    z=z-p1*z2/(cos(z)+z1)
  974.     .0001 < |z2|
  975.   }
  976.  
  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.
  981.   ; Try P1=1.8.
  982.   z=(1,1):
  983.    z2=z*z
  984.    z3=z*z2
  985.    z=z-p1*(z3-pixel)/(3.0*z2)
  986.     0.0001 < |z3-pixel|
  987.   }
  988.  
  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.
  994.   a=(0,0),b=(0,0):
  995.    z=z+1
  996.    anew=sqr(a)-sqr(b)+pixel
  997.    b=2.0*a*b+p1
  998.    a=anew
  999.     |a|+|b| <= 4
  1000.   }
  1001.  
  1002. OldHalleySin (XYAXIS) {
  1003.   z=pixel:
  1004.    s=sin(z)
  1005.    c=cosxx(z)
  1006.    z=z-p1*(s/(c-(s*s)/(c+c)))
  1007.     0.0001 <= |s|
  1008.   }
  1009.  
  1010. {--- RICHARD HUGHES ------------------------------------------------------}
  1011.  
  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)
  1018.     |z| <= 4
  1019.   }
  1020.  
  1021. {--- GORDON LAMB ---------------------------------------------------------}
  1022.  
  1023. SJMAND01 {;Mandelbrot
  1024.   z=real(pixel)+flip(imag(pixel)*p1)
  1025.   c=p2+p1*real(pixel)+flip(imag(pixel)):
  1026.    z=z*z+c
  1027.     |z|<=64
  1028.   }
  1029.  
  1030. 3RDIM01 {;Mandelbrot
  1031.   z=p1*real(pixel)+flip(imag(pixel))
  1032.   c=p2+real(pixel)+flip(imag(pixel)*p1):
  1033.    z=z*z+c
  1034.     |z|<=64
  1035.   }
  1036.  
  1037. SJMAND03 {;Mandelbrot function
  1038.   z=real(pixel)+p1*(flip(imag(pixel)))
  1039.   c=p2+p1*real(pixel)+flip(imag(pixel)):
  1040.    z=fn1(z)+c
  1041.     |z|<=64
  1042.   }
  1043.  
  1044. SJMAND05 {;Mandelbrot lambda function
  1045.   z=real(pixel)+flip(imag(pixel)*p1)
  1046.   c=p2+p1*real(pixel)+flip(imag(pixel)):
  1047.    z=fn1(z)*c
  1048.     |z|<=64
  1049.   }
  1050.  
  1051. 3RDIM05 {;Mandelbrot lambda function
  1052.   z=p1*real(pixel)+flip(imag(pixel))
  1053.   c=p2+real(pixel)+flip(imag(pixel)*p1):
  1054.    z=fn1(z)*c
  1055.     |z|<=64
  1056.   }
  1057.  
  1058. SJMAND10 {;Mandelbrot power function
  1059.   z=real(pixel),c=p2+flip(imag(pixel)):
  1060.    z=(fn1(z)+c)^p1
  1061.     |z|<=4
  1062.   }
  1063.  
  1064. SJMAND11 {;Mandelbrot lambda function - lower bailout
  1065.   z=real(pixel)+flip(imag(pixel)*p1)
  1066.   c=p2+p1*real(pixel)+flip(imag(pixel)):
  1067.    z=fn1(z)*c
  1068.     |z|<=4
  1069.   }
  1070.  
  1071. {--- KEVIN LEE -----------------------------------------------------------}
  1072.  
  1073. LeeMandel1(XYAXIS) {; Kevin Lee
  1074.   z=Pixel:
  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)
  1077.     |z|<4
  1078.   }
  1079.  
  1080. LeeMandel2(XYAXIS) {; Kevin Lee
  1081.   z=Pixel:
  1082.    c=sqr(pixel)/z, c=z+c, z=sqr(c*pixel)
  1083.     |z|<4
  1084.    }
  1085.  
  1086. LeeMandel3(XAXIS) {; Kevin Lee
  1087.   z=Pixel, c=Pixel-sqr(z):
  1088.    c=Pixel+c/z, z=c-z*pixel
  1089.     |z|<4
  1090.   }
  1091.  
  1092. {--- RON LEWEN -----------------------------------------------------------}
  1093.  
  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
  1098.   ; to zoom in on.
  1099.   ; Use floating point.
  1100.   z=pixel:
  1101.    z=p1*fn1(fn2(z+p1))
  1102.     |z| <= 4
  1103.   }
  1104.  
  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
  1111.   z=.001:
  1112.    z=z^p1+(1/pixel)^p1
  1113.     |z| <= 100
  1114.   }
  1115.  
  1116. RCL_1 (XAXIS) { ; Ron Lewen
  1117.   ;  An interesting Biomorph inspired by Pickover's
  1118.   ;  Computers, Pattern, Choas and Beauty.
  1119.   ;  Use Floating Point
  1120.   z=pixel:
  1121.    z=pixel/z-z^2
  1122.     |real(z)| <= 100 || |imag(z)| <= 100
  1123.   }
  1124.  
  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
  1131.   z=0:
  1132.    z=cosh(z) + pixel
  1133.     abs(z) < 40
  1134.   }
  1135.  
  1136. Mothra (XAXIS) { ; Ron Lewen, 76376,2567
  1137.   ; Remember Mothra, the giant Japanese-eating moth?
  1138.   ; Well... here he (she?) is as a fractal!
  1139.   z=pixel:
  1140.    a=z^5 + z^3 + z + pixel
  1141.    b=z^4 + z^2 + pixel
  1142.    z=b^2/a,
  1143.     |real(z)| <= 100 || |imag(z)| <= 100
  1144.   }
  1145.  
  1146. RCL_10 { ; Ron Lewen, 76376,2567
  1147.   z=pixel:
  1148.    z=flip((z^2+pixel)/(pixel^2+z))
  1149.     |z| <= 4
  1150.   }
  1151.  
  1152. {--- LEE SKINNER ---------------------------------------------------------}
  1153.  
  1154. MTet (XAXIS) {; Mandelbrot form 1 of the Tetration formula --Lee Skinner
  1155.   z = pixel:
  1156.    z = (pixel ^ z) + pixel
  1157.     |z| <= (P1 + 3)
  1158.   }
  1159.  
  1160. AltMTet(XAXIS) {; Mandelbrot form 2 of the Tetration formula --Lee Skinner
  1161.   z = 0:
  1162.    z = (pixel ^ z) + pixel
  1163.     |z| <= (P1 + 3)
  1164.   }
  1165.  
  1166. JTet (XAXIS) {; Julia form 1 of the Tetration formula --Lee Skinner
  1167.   z = pixel:
  1168.    z = (pixel ^ z) + P1
  1169.     |z| <= (P2 + 3)
  1170.   }
  1171.  
  1172. AltJTet (XAXIS) {; Julia form 2 of the Tetration formula --Lee Skinner
  1173.   z = P1:
  1174.    z = (pixel ^ z) + P1
  1175.     |z| <= (P2 + 3)
  1176.   }
  1177.  
  1178. Cubic (XYAXIS) {; Lee Skinner
  1179.   p = pixel, test = p1 + 3
  1180.   t3 = 3*p, t2 = p*p
  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
  1184.     |z| < test
  1185.  }
  1186.  
  1187. Fzppfnre {; Lee Skinner
  1188.   z = pixel, f = 1./(pixel):
  1189.    z = fn1(z) + f
  1190.     |z| <= 50
  1191.   }
  1192.  
  1193. Fzppfnpo {; Lee Skinner
  1194.   z = pixel, f = (pixel)^(pixel):
  1195.    z = fn1(z) + f
  1196.     |z| <= 50
  1197.   }
  1198.  
  1199. Fzppfnsr {; Lee Skinner
  1200.   z = pixel, f = (pixel)^.5:
  1201.    z = fn1(z) + f
  1202.     |z| <= 50
  1203.   }
  1204.  
  1205. Fzppfnta {; Lee Skinner
  1206.   z = pixel, f = tan(pixel):
  1207.    z = fn1(z) + f
  1208.     |z|<= 50
  1209.   }
  1210.  
  1211. Fzppfnct {; Lee Skinner
  1212.   z = pixel, f = cos(pixel)/sin(pixel):
  1213.    z = fn1(z) + f
  1214.     |z|<= 50
  1215.   }
  1216.  
  1217. Fzppfnse {; Lee Skinner
  1218.   z = pixel, f = 1./sin(pixel):
  1219.    z = fn1(z) + f
  1220.     |z| <= 50
  1221.   }
  1222.  
  1223. Fzppfncs {; Lee Skinner
  1224.   z = pixel, f = 1./cos(pixel):
  1225.    z = fn1(z) + f
  1226.     |z| <= 50
  1227.   }
  1228.  
  1229. Fzppfnth {; Lee Skinner
  1230.   z = pixel, f = tanh(pixel):
  1231.    z = fn1(z)+f
  1232.     |z|<= 50
  1233.   }
  1234.  
  1235. Fzppfnht {; Lee Skinner
  1236.   z = pixel, f = cosh(pixel)/sinh(pixel):
  1237.    z = fn1(z)+f
  1238.     |z|<= 50
  1239.   }
  1240.  
  1241. Fzpfnseh {; Lee Skinner
  1242.   z = pixel, f = 1./sinh(pixel):
  1243.    z = fn1(z) + f
  1244.     |z| <= 50
  1245.   }
  1246.  
  1247. Fzpfncoh {; Lee Skinner
  1248.   z = pixel, f = 1./cosh(pixel):
  1249.    z = fn1(z) + f
  1250.     |z| <= 50
  1251.   }
  1252.  
  1253. Zexpe (XAXIS) {
  1254.   s = exp(1.,0.), z = Pixel:
  1255.    z = z ^ s + pixel
  1256.     |z| <= 100
  1257.   }
  1258.  
  1259. comment {
  1260.   s = log(-1.,0.) / (0.,1.)   is   (3.14159265358979, 0.0)
  1261.   }
  1262.  
  1263. Exipi (XAXIS) {
  1264.   s = log(-1.,0.) / (0.,1.), z = Pixel:
  1265.    z = z ^ s + pixel
  1266.     |z| <= 100
  1267.   }
  1268.  
  1269. Fzppchco {
  1270.   z = pixel, f = cosxx (pixel):
  1271.    z = cosh (z) + f
  1272.     |z| <= 50
  1273.   }
  1274.  
  1275. Fzppcosq {
  1276.   z = pixel, f = sqr (pixel):
  1277.    z = cosxx (z)  + f
  1278.     |z| <= 50
  1279.   }
  1280.  
  1281. Fzppcosr {
  1282.   z = pixel, f = (pixel) ^ 0.5:
  1283.    z = cosxx (z)  + f
  1284.     |z| <= 50
  1285.   }
  1286.  
  1287. Leeze (XAXIS) {
  1288.   s = exp(1.,0.), z = Pixel, f = Pixel ^ s:
  1289.    z = cosxx (z) + f
  1290.     |z| <= 50
  1291.   }
  1292.  
  1293. OldManowar (XAXIS) {
  1294.   z0 = 0
  1295.   z1 = 0
  1296.   test = p1 + 3
  1297.   c = pixel :
  1298.    z = z1*z1 + z0 + c
  1299.    z0 = z1
  1300.    z1 = z
  1301.     |z| < test
  1302.   }
  1303.  
  1304. ScSkLMS(XAXIS) {
  1305.   z = pixel, TEST = (p1+3):
  1306.    z = log(z) - sin(z)
  1307.     |z|<TEST
  1308.   }
  1309.  
  1310. ScSkZCZZ(XYAXIS) {
  1311.   z = pixel, TEST = (p1+3):
  1312.    z = (z*cosxx(z)) - z
  1313.     |z|<TEST
  1314.   }
  1315.  
  1316. TSinh (XAXIS) {; Tetrated Hyperbolic Sine - Improper Bailout
  1317.   z = c = sinh(pixel):
  1318.    z = c ^ z
  1319.     z <= (p1 + 3)
  1320.   }
  1321.  
  1322. {--- SCOTT TAYLOR --------------------------------------------------------}
  1323.  
  1324. comment {
  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.
  1328.   }
  1329.  
  1330. FnDog(XYAXIS) {; Scott Taylor
  1331.   z = Pixel, b = p1+2:
  1332.    z = fn1( z ) * pixel
  1333.     |z| <= b
  1334.   }
  1335.  
  1336. Ent {; Scott Taylor
  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):
  1341.    z = y * log(z)/base
  1342.     |z| <= 4
  1343.   }
  1344.  
  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 )
  1349.     |z| <= 4
  1350.   }
  1351.  
  1352. {--- MICHAEL THEROUX & RON BARNETT ---------------------------------------}
  1353.  
  1354. test3 {; Michael Theroux [71673,2767]
  1355.   ;fix and generalization by Ron Barnett [70153,1233]
  1356.   ;=phi
  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)
  1360.     |z| <= 4
  1361.   }
  1362.  
  1363. {--- TIMOTHY WEGNER ------------------------------------------------------}
  1364.  
  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))
  1370.    z2 = z*z
  1371.    z3 = z*z2
  1372.    .004 <= |z3 + (p1-1)*z - p1|
  1373.   }
  1374.  
  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)
  1384.    z2 = z*z
  1385.    z3 = z*z2
  1386.     p2 <= |z3 + p1*z2 + 1|  ; no need for sqrt because sqrt(z)==0 iff z==0
  1387.   }
  1388.  
  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)
  1394.    z2 = z*z
  1395.    z3 = z*z2
  1396.     p2 <= |z3 + p1*z2 + 1|  ; no need for sqr because sqr(z)==0 iff z==0
  1397.   }
  1398.  
  1399. {--- TIM WEGNER & MARK PETERSON ------------------------------------------}
  1400.  
  1401. comment {
  1402.   These are a few of the examples from the book, Fractal Creations, by Tim
  1403.   Wegner and Mark Peterson.
  1404.   }
  1405.  
  1406. MyFractal {; Fractal Creations example
  1407.   c = z = 1/pixel:
  1408.    z = sqr(z) + c
  1409.     |z| <= 4
  1410.   }
  1411.  
  1412. MandelTangent {; Fractal Creations example (revised for v.16)
  1413.   z = pixel:
  1414.    z = pixel * tan(z)
  1415.     |real(z)| < 32
  1416.   }
  1417.  
  1418. Mandel3 {; Fractal Creations example
  1419.   z = pixel, c = sin(z):
  1420.    z = (z*z) + c
  1421.    z = z * 1/c
  1422.     |z| <= 4
  1423.   }
  1424.  
  1425. {--- AUTHORS UNKNOWN -----------------------------------------------------}
  1426.  
  1427. moc {
  1428.   z=0, c=pixel:
  1429.    z=sqr(z)+c
  1430.    c=c+p1/c
  1431.     |z| <= 4
  1432.   }
  1433.  
  1434. Bali {;The difference of two squares
  1435.   z=x=1/pixel, c= fn1 (z):
  1436.    z = (x+c) * (x-c)
  1437.    x=fn2(z)
  1438.     |z| <=3
  1439.   }
  1440.  
  1441. Fatso {;
  1442.   z=x=1/pixel, c= fn1 (z):
  1443.    z = (x^3)-(c^3)
  1444.    x=fn2(z)
  1445.     |z| <=3
  1446.   }
  1447.  
  1448. Bjax {;
  1449.   z=c=2/pixel:
  1450.    z =(1/((z^(real(p1)))*(c^(real(p2))))*c) + c
  1451.   }
  1452.  
  1453. ULI_4 {
  1454.   z = Pixel:
  1455.    z = fn1(1/(z+p1))*fn2(z+p1)
  1456.     |z| <= p2
  1457.   }
  1458.  
  1459. ULI_5 {
  1460.   z = Pixel, c = fn1(pixel):
  1461.    z = fn2(1/(z+c))*fn3(z+c)
  1462.     |z| <= p1
  1463.   }
  1464.  
  1465. ULI_6 {
  1466.   z = Pixel:
  1467.    z = fn1(p1+z)*fn2(p2-z)
  1468.     |z| <= p2+16
  1469.   }
  1470.