home *** CD-ROM | disk | FTP | other *** search
/ Shareware Breakthrough: Entertainment & Education / SharewearBreakthroughEnt_Ed.cdr / games / winfract / fractint.frm < prev    next >
Text File  |  1991-05-31  |  15KB  |  632 lines
  1. comment {
  2.  FRACTINT.DOC has instructions for adding new formulas to this file.
  3.  There are several hard-coded restrictions in the formula interpreter:
  4.  
  5.  1) The fractal name through the open curly bracket must be on a single line.
  6.  2) There is a hard-coded limit of 200 formulas per formula file, only
  7.     because of restrictions in the prompting routines.
  8.  3) Formulas can containt at most 250 operations (references to variables and
  9.     arithmetic); this is bigger than it sounds, no formula in the default
  10.     fractint.frm uses even 100
  11.  3) Comment blocks can be set up using dummy formulas with no formula name
  12.     or with the special name "comment".
  13.  
  14.  The formulas at the beginning of this file are from Mark Peterson, who
  15.  built this fractal interpreter feature.  The rest are grouped by contributor.
  16.  (Scott Taylor sent many but they are no longer here - they've been
  17.  incorporated as hard-coded types.  Lee Skinner also sent many which have
  18.  now been hard-coded.)
  19.  
  20.  Note that the builtin "cos" function had a bug which was corrected in
  21.  version 16.  To recreate an image from a formula which used cos before
  22.  v16, change "cos" in the formula to "cosxx" which is a new function
  23.  provided for backward compatibility with that bug.
  24.  }
  25.  
  26. Mandelbrot(XAXIS) {; Mark Peterson
  27.   ; Classical fractal showing LastSqr speedup
  28.   z = Pixel, z = Sqr(z):  ; Start with z**2 to initialize LastSqr
  29.    z = z + Pixel
  30.    z = Sqr(z)
  31.     LastSqr <= 4      ; Use LastSqr instead of recalculating
  32.   }
  33.  
  34. Dragon (ORIGIN) {; Mark Peterson
  35.   z = Pixel:
  36.    z = sqr(z) + (-0.74543, 0.2),
  37.     |z| <= 4
  38.   }
  39.  
  40. Daisy (ORIGIN) {; Mark Peterson
  41.   z = pixel:
  42.    z = z*z + (0.11031, -0.67037),
  43.     |z| <= 4
  44.   }
  45.  
  46. InvMandel (XAXIS) {; Mark Peterson
  47.   c = z = 1 / pixel:
  48.    z = sqr(z) + c;
  49.     |z| <= 4
  50.   }
  51.  
  52. DeltaLog(XAXIS) {; Mark Peterson
  53.   z = pixel, c = log(pixel):
  54.    z = sqr(z) + c,
  55.     |z| <= 4
  56.   }
  57.  
  58. Newton4(XYAXIS) {; Mark Peterson
  59.   z = pixel, Root = 1:
  60.    z3 = z*z*z;
  61.    z4 = z3 * z;
  62.    z = (3 * z4 + Root) / (4 * z3);
  63.     .004 <= |z4 - Root|
  64.   }
  65.  
  66. comment {
  67.    The following are from Chris Green:
  68.    These fractals all use Newton's or Halley's formula for approximation
  69.    of a function.  In all of these fractals, p1 is the "relaxation
  70.    coefficient". A value of 1 gives the conventional newton or halley
  71.    iteration. Values <1 will generally produce less chaos than values >1.
  72.    1-1.5 is probably a good range to try.  P2 is the imaginary component
  73.    of the relaxation coefficient, and should be zero but maybe a small
  74.    non-zero value will produce something interesting. Who knows?
  75.    For more information on Halley maps, see "Computers, Pattern, Chaos,
  76.    and Beauty" by Pickover.
  77.    }
  78.  
  79. Halley (XYAXIS) {; Chris Green. Halley's formula applied to x^7-x=0.
  80.   ; P1 usually 1 to 1.5, P2 usually zero. Use floating point.
  81.   ; Setting P1 to 1 creates the picture on page 277 of Pickover's book
  82.   z=pixel:
  83.    z5=z*z*z*z*z;
  84.    z6=z*z5;
  85.    z7=z*z6;
  86.    z=z-p1*((z7-z)/ ((7.0*z6-1)-(42.0*z5)*(z7-z)/(14.0*z6-2))),
  87.     0.0001 <= |z7-z|
  88.   }
  89.  
  90. CGhalley (XYAXIS) {; Chris Green -- Halley's formula
  91.   ; P1 usually 1 to 1.5, P2 usually zero. Use floating point.
  92.   z=(1,1):
  93.    z5=z*z*z*z*z;
  94.    z6=z*z5;
  95.    z7=z*z6;
  96.    z=z-p1*((z7-z-pixel)/ ((7.0*z6-1)-(42.0*z5)*(z7-z-pixel)/(14.0*z6-2))),
  97.     0.0001 <= |z7-z-pixel|
  98.   }
  99.  
  100. halleySin (XYAXIS) {; Chris Green. Halley's formula applied to sin(x)=0.
  101.   ; Use floating point.
  102.   ; P1 = 0.1 will create the picture from page 281 of Pickover's book.
  103.   z=pixel:
  104.    s=sin(z), c=cos(z)
  105.    z=z-p1*(s/(c-(s*s)/(c+c))),
  106.     0.0001 <= |s|
  107.   }
  108.  
  109. NewtonSinExp (XAXIS) {; Chris Green
  110.   ; Newton's formula applied to sin(x)+exp(x)-1=0.
  111.   ; Use floating point.
  112.   z=pixel:
  113.    z1=exp(z)
  114.    z2=sin(z)+z1-1
  115.    z=z-p1*z2/(cos(z)+z1),
  116.     .0001 < |z2|
  117.   }
  118.  
  119. CGNewton3 {; Chris Green -- A variation on newton iteration.
  120.   ; The initial guess is fixed at (1,1), but the equation solved
  121.   ; is different at each pixel ( x^3-pixel=0 is solved).
  122.   ; Use floating point.
  123.   ; Try P1=1.8.
  124.   z=(1,1):
  125.    z2=z*z;
  126.    z3=z*z2;
  127.    z=z-p1*(z3-pixel)/(3.0*z2),
  128.     0.0001 < |z3-pixel|
  129.   }
  130.  
  131. HyperMandel {; Chris Green.
  132.   ; A four dimensional version of the mandelbrot set.
  133.   ; Use P1 to select which two-dimensional plane of the
  134.   ; four dimensional set you wish to examine.
  135.   ; Use floating point.
  136.   a=(0,0),b=(0,0):
  137.    z=z+1
  138.    anew=sqr(a)-sqr(b)+pixel
  139.    b=2.0*a*b+p1
  140.    a=anew,
  141.     |a|+|b| <= 4
  142.   }
  143.  
  144.  
  145. MTet (XAXIS) {; Mandelbrot form 1 of the Tetration formula --Lee Skinner
  146.   z = pixel:
  147.    z = (pixel ^ z) + pixel,
  148.     |z| <= (P1 + 3)
  149.   }
  150.  
  151. AltMTet(XAXIS) {; Mandelbrot form 2 of the Tetration formula --Lee Skinner
  152.   z = 0:
  153.    z = (pixel ^ z) + pixel,
  154.     |z| <= (P1 + 3)
  155.   }
  156.  
  157. JTet (XAXIS) {; Julia form 1 of the Tetration formula --Lee Skinner
  158.   z = pixel:
  159.    z = (pixel ^ z) + P1,
  160.     |z| <= (P2 + 3)
  161.   }
  162.  
  163. AltJTet (XAXIS) {; Julia form 2 of the Tetration formula --Lee Skinner
  164.   z = P1:
  165.    z = (pixel ^ z) + P1,
  166.     |z| <= (P2 + 3)
  167.   }
  168.  
  169. Cubic (XYAXIS) {; Lee Skinner
  170.   p = pixel, test = p1 + 3,
  171.   t3 = 3*p, t2 = p*p,
  172.   a = (t2 + 1)/t3, b = 2*a*a*a + (t2 - 2)/t3,
  173.   aa3 = a*a*3, z = 0 - a :
  174.    z = z*z*z - aa3*z + b,
  175.     |z| < test
  176.  }
  177.  
  178. { The following are from Lee Skinner, have been partially generalized. }
  179.  
  180. Fzppfnre  {; Lee Skinner
  181.   z = pixel, f = 1./(pixel):
  182.    z = fn1(z) + f,
  183.     |z| <= 50
  184.   }
  185.  
  186. Fzppfnpo  {; Lee Skinner
  187.   z = pixel, f = (pixel)^(pixel):
  188.    z = fn1(z) + f,
  189.     |z| <= 50
  190.   }
  191.  
  192. Fzppfnsr  {; Lee Skinner
  193.   z = pixel, f = (pixel)^.5:
  194.    z = fn1(z) + f,
  195.     |z| <= 50
  196.   }
  197.  
  198. Fzppfnta  {; Lee Skinner
  199.   z = pixel, f = tan(pixel):
  200.    z = fn1(z) + f,
  201.     |z|<= 50
  202.   }
  203.  
  204. Fzppfnct  {; Lee Skinner
  205.   z = pixel, f = cos(pixel)/sin(pixel):
  206.    z = fn1(z) + f,
  207.     |z|<= 50
  208.   }
  209.  
  210. Fzppfnse  {; Lee Skinner
  211.   z = pixel, f = 1./sin(pixel):
  212.    z = fn1(z) + f,
  213.     |z| <= 50
  214.   }
  215.  
  216. Fzppfncs  {; Lee Skinner
  217.   z = pixel, f = 1./cos(pixel):
  218.    z = fn1(z) + f,
  219.     |z| <= 50
  220.   }
  221.  
  222. Fzppfnth  {; Lee Skinner
  223.   z = pixel, f = tanh(pixel):
  224.    z = fn1(z)+f,
  225.     |z|<= 50
  226.   }
  227.  
  228. Fzppfnht  {; Lee Skinner
  229.   z = pixel, f = cosh(pixel)/sinh(pixel):
  230.    z = fn1(z)+f,
  231.     |z|<= 50
  232.   }
  233.  
  234. Fzpfnseh  {; Lee Skinner
  235.   z = pixel, f = 1./sinh(pixel):
  236.    z = fn1(z) + f,
  237.     |z| <= 50
  238.   }
  239.  
  240. Fzpfncoh  {; Lee Skinner
  241.   z = pixel, f = 1./cosh(pixel):
  242.    z = fn1(z) + f,
  243.     |z| <= 50
  244.   }
  245.  
  246.  
  247. { The following resulted from a FRACTINT bug. Version 13 incorrectly
  248.   calculated Spider (see above). We fixed the bug, and reverse-engineered
  249.   what it was doing to Spider - so here is the old "spider" }
  250.  
  251. Wineglass(XAXIS) {; Pieter Branderhorst
  252.   c = z = pixel:
  253.    z = z * z + c
  254.    c = (1+flip(imag(c))) * real(c) / 2 + z,
  255.     |z| <= 4 }
  256.  
  257.  
  258. { The following is from Scott Taylor.
  259.   Scott says they're "Dog" because the first one he looked at reminded him
  260.   of a hot dog. This was originally several fractals, we have generalized it. }
  261.  
  262. FnDog(XYAXIS)  {; Scott Taylor
  263.   z = Pixel, b = p1+2:
  264.    z = fn1( z ) * pixel,
  265.     |z| <= b
  266.   }
  267.  
  268. Ent {; Scott Taylor
  269.   ; Try params=.5/.75 and the first function as exp.
  270.   ; Zoom in on the swirls around the middle.  There's a
  271.   ; symmetrical area surrounded by an asymmetric area.
  272.   z = Pixel, y = fn1(z), base = log(p1):
  273.    z = y * log(z)/base,
  274.     |z| <= 4
  275.   }
  276.  
  277. Ent2 {; Scott Taylor
  278.   ; try params=2/1, functions=cos/cosh, potential=255/355
  279.   z = Pixel, y = fn1(z), base = log(p1):
  280.    z = fn2( y * log(z) / base ),
  281.     |z| <= 4
  282.   }
  283.  
  284. { From Kevin Lee: }
  285.  
  286. LeeMandel1(XYAXIS) {; Kevin Lee
  287.   z=Pixel:
  288.    c=sqr(pixel)/z, c=z+c, z=sqr(z),
  289.     |z|<4
  290.   }
  291.  
  292. LeeMandel2(XYAXIS) {; Kevin Lee
  293.   z=Pixel:
  294.    c=sqr(pixel)/z, c=z+c, z=sqr(c*pixel),
  295.     |z|<4
  296.    }
  297.  
  298. LeeMandel3(XAXIS) {; Kevin Lee
  299.   z=Pixel, c=Pixel-sqr(z):
  300.    c=Pixel+c/z, z=c-z*pixel,
  301.     |z|<4
  302.   }
  303.  
  304. { These are a few of the examples from the book,
  305.   Fractal Creations, by Tim Wegner and Mark Peterson. }
  306.  
  307. MyFractal {; Fractal Creations example
  308.   c = z = 1/pixel:
  309.    z = sqr(z) + c;
  310.     |z| <= 4
  311.   }
  312.  
  313. Bogus1 {; Fractal Creations example
  314.   z = 0; z = z + * 2,
  315.    |z| <= 4 }
  316.  
  317. MandelTangent {; Fractal Creations example (revised for v.16)
  318.   z = pixel:
  319.    z = pixel * tan(z),
  320.     |real(z)| < 32
  321.   }
  322.  
  323. Mandel3 {; Fractal Creations example
  324.   z = pixel, c = sin(z):
  325.    z = (z*z) + c;
  326.    z = z * 1/c;
  327.     |z| <= 4;
  328.    }
  329.  
  330. { These are from: "AKA MrWizard W. LeRoy Davis;SM-ALC/HRUC"
  331.           davisl@sm-logdis1-aflc.af.mil
  332.   The first 3 are variations of:
  333.                z
  334.        gamma(z) = (z/e) * sqrt(2*pi*z) * R        }
  335.  
  336. Sterling(XAXIS) {; davisl
  337.   z = Pixel:
  338.    z = ((z/2.7182818)^z)/sqr(6.2831853*z),
  339.     |z| <= 4
  340.   }
  341.  
  342. Sterling2(XAXIS) {; davisl
  343.   z = Pixel:
  344.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) + pixel,
  345.     |z| <= 4
  346.   }
  347.  
  348. Sterling3(XAXIS) {; davisl
  349.   z = Pixel:
  350.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) - pixel,
  351.     |z| <= 4
  352.   }
  353.  
  354. PsudoMandel(XAXIS) {; davisl - try center=0,0/magnification=28
  355.   z = Pixel:
  356.    z = ((z/2.7182818)^z)*sqr(6.2831853*z) + pixel,
  357.     |z| <= 4
  358.   }
  359.  
  360. { These are the original "Richard" types sent by Jm Richard-Collard. Their
  361.   generalizations are tacked on to the end of the "Jm" list below, but
  362.   we felt we should keep these around for historical reasons.}
  363.  
  364. Richard1 (XYAXIS) {; Jm Richard-Collard
  365.   z = pixel:
  366.    sq=z*z, z=(sq*sin(sq)+sq)+pixel,
  367.     |z|<=50
  368.   }
  369.  
  370. Richard2 (XYAXIS) {; Jm Richard-Collard
  371.   z = pixel:
  372.    z=1/(sin(z*z+pixel*pixel)),
  373.     |z|<=50
  374.   }
  375.  
  376. Richard3 (XAXIS) {; Jm Richard-Collard
  377.   z = pixel:
  378.    sh=sinh(z), z=(1/(sh*sh))+pixel,
  379.     |z|<=50
  380.   }
  381.  
  382. Richard4 (XAXIS) {; Jm Richard-Collard
  383.   z = pixel:
  384.    z2=z*z, z=(1/(z2*cos(z2)+z2))+pixel,
  385.     |z|<=50
  386.   }
  387.  
  388. Richard5 (XAXIS) {; Jm Richard-Collard
  389.   z = pixel:
  390.    z=sin(z*sinh(z))+pixel,
  391.     |z|<=50
  392.   }
  393.  
  394. Richard6 (XYAXIS) {; Jm Richard-Collard
  395.   z = pixel:
  396.    z=sin(sinh(z))+pixel,
  397.     |z|<=50
  398.   }
  399.  
  400. Richard7 (XAXIS) {; Jm Richard-Collard
  401.   z=pixel:
  402.    z=log(z)*pixel,
  403.     |z|<=50
  404.   }
  405.  
  406. Richard8 (XYAXIS) {; Jm Richard-Collard
  407.   ; This was used for the "Fractal Creations" cover
  408.   z=pixel,sinp = sin(pixel):
  409.    z=sin(z)+sinp,
  410.     |z|<=50
  411.   }
  412.  
  413. Richard9 (XAXIS) {; Jm Richard-Collard
  414.   z=pixel:
  415.    sqrz=z*z, z=sqrz + 1/sqrz + pixel,
  416.     |z|<=4
  417.   }
  418.  
  419. Richard10(XYAXIS) {; Jm Richard-Collard
  420.   z=pixel:
  421.    z=1/sin(1/(z*z)),
  422.     |z|<=50
  423.   }
  424.  
  425. Richard11(XYAXIS) {; Jm Richard-Collard
  426.   z=pixel:
  427.    z=1/sinh(1/(z*z)),
  428.     |z|<=50
  429.   }
  430.  
  431. { These types are generalizations of types sent to us by the French
  432.   mathematician Jm Richard-Collard. If we hadn't generalized them
  433.   there would be --ahhh-- quite a few. With 11 possible values for
  434.   each fn variable,Jm_03, for example, has 14641 variations! }
  435.  
  436. Jm_01 {; generalized Jm Richard-Collard type
  437.   z=pixel,t=p1+4:
  438.    z=(fn1(fn2(z^pixel)))*pixel,
  439.     |z|<=t
  440.   }
  441.  
  442. Jm_02 {; generalized Jm Richard-Collard type
  443.   z=pixel,t=p1+4:
  444.    z=(z^pixel)*fn1(z^pixel),
  445.     |z|<=t
  446.   }
  447.  
  448. Jm_03 {; generalized Jm Richard-Collard type
  449.   z=pixel,t=p1+4:
  450.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))*pixel,
  451.     |z|<=t
  452.   }
  453.  
  454. Jm_04 {; generalized Jm Richard-Collard type
  455.   z=pixel,t=p1+4:
  456.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel)),
  457.     |z|<=t
  458.   }
  459.  
  460. Jm_05 {; generalized Jm Richard-Collard type
  461.   z=pixel,t=p1+4:
  462.    z=fn1(fn2((z^pixel))),
  463.     |z|<=t
  464.   }
  465.  
  466. Jm_06 {; generalized Jm Richard-Collard type
  467.   z=pixel,t=p1+4:
  468.    z=fn1(fn2(fn3((z^z)*pixel))),
  469.     |z|<=t
  470.   }
  471.  
  472. Jm_07 {; generalized Jm Richard-Collard type
  473.   z=pixel,t=p1+4:
  474.    z=fn1(fn2(fn3((z^z)*pixel)))*pixel,
  475.     |z|<=t
  476.   }
  477.  
  478. Jm_08 {; generalized Jm Richard-Collard type
  479.   z=pixel,t=p1+4:
  480.    z=fn1(fn2(fn3((z^z)*pixel)))+pixel,
  481.     |z|<=t
  482.   }
  483.  
  484. Jm_09 {; generalized Jm Richard-Collard type
  485.   z=pixel,t=p1+4:
  486.    z=fn1(fn2(fn3(fn4(z))))+pixel,
  487.     |z|<=t
  488.   }
  489.  
  490. Jm_10 {; generalized Jm Richard-Collard type
  491.   z=pixel,t=p1+4:
  492.    z=fn1(fn2(fn3(fn4(z)*pixel))),
  493.     |z|<=t
  494.   }
  495.  
  496. Jm_11 {; generalized Jm Richard-Collard type
  497.   z=pixel,t=p1+4:
  498.    z=fn1(fn2(fn3(fn4(z)*pixel)))*pixel,
  499.     |z|<=t
  500.   }
  501.  
  502. Jm_12 {; generalized Jm Richard-Collard type
  503.   z=pixel,t=p1+4:
  504.    z=fn1(fn2(fn3(z)*pixel)),
  505.     |z|<=t
  506.   }
  507.  
  508. Jm_13 {; generalized Jm Richard-Collard type
  509.   z=pixel,t=p1+4:
  510.    z=fn1(fn2(fn3(z)*pixel))*pixel,
  511.     |z|<=t
  512.   }
  513.  
  514. Jm_14 {; generalized Jm Richard-Collard type
  515.   z=pixel,t=p1+4:
  516.    z=fn1(fn2(fn3(z)*pixel))+pixel,
  517.     |z|<=t
  518.   }
  519.  
  520. Jm_15 {; generalized Jm Richard-Collard type
  521.   z=pixel,t=p1+4:
  522.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))*pixel,
  523.     |z|<=t
  524.   }
  525.  
  526. Jm_16 {; generalized Jm Richard-Collard type
  527.   z=pixel,t=p1+4:
  528.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))+pixel,
  529.     |z|<=t
  530.   }
  531.  
  532. Jm_17 {; generalized Jm Richard-Collard type
  533.   z=pixel,t=p1+4:
  534.    z=fn1(z)*pixel*fn2(fn3(z)),
  535.     |z|<=t
  536.   }
  537.  
  538. Jm_18 {; generalized Jm Richard-Collard type
  539.   z=pixel,t=p1+4:
  540.    z=fn1(z)*pixel*fn2(fn3(z)*pixel),
  541.     |z|<=t
  542.   }
  543.  
  544. Jm_19 {; generalized Jm Richard-Collard type
  545.   z=pixel,t=p1+4:
  546.    z=fn1(z)*pixel*fn2(fn3(z)+pixel),
  547.     |z|<=t
  548.   }
  549.  
  550. Jm_20 {; generalized Jm Richard-Collard type
  551.   z=pixel,t=p1+4:
  552.    z=fn1(z^pixel),
  553.     |z|<=t
  554.   }
  555.  
  556. Jm_21 {; generalized Jm Richard-Collard type
  557.   z=pixel,t=p1+4:
  558.    z=fn1(z^pixel)*pixel,
  559.     |z|<=t
  560.   }
  561.  
  562. Jm_22 {; generalized Jm Richard-Collard type
  563.   z=pixel,t=p1+4:
  564.    sq=fn1(z), z=(sq*fn2(sq)+sq)+pixel,
  565.     |z|<=t
  566.   }
  567.  
  568. Jm_23 {; generalized Jm Richard-Collard type
  569.   z=pixel,t=p1+4:
  570.    z=fn1(fn2(fn3(z)+pixel*pixel)),
  571.     |z|<=t
  572.   }
  573.  
  574. Jm_24 {; generalized Jm Richard-Collard type
  575.   z=pixel,t=p1+4:
  576.    z2=fn1(z), z=(fn2(z2*fn3(z2)+z2))+pixel,
  577.     |z|<=t
  578.   }
  579.  
  580. Jm_25 {; generalized Jm Richard-Collard type
  581.   z=pixel,t=p1+4:
  582.    z=fn1(z*fn2(z)) + pixel,
  583.     |z|<=t
  584.   }
  585.  
  586. Jm_26 {; generalized Jm Richard-Collard type
  587.   z=pixel,t=p1+4:
  588.    z=fn1(fn2(z)) + pixel,
  589.     |z|<=t
  590.   }
  591.  
  592. Jm_27 {; generalized Jm Richard-Collard type
  593.   z=pixel,t=p1+4:
  594.    sqrz=fn1(z), z=sqrz + 1/sqrz + pixel,
  595.     |z|<=t
  596.   }
  597.  
  598. Jm_ducks(XAXIS) {; Jm Richard-Collard
  599.   ; Not so ugly at first glance and lot of corners to zoom in.
  600.   ; try this: corners=-1.178372/-0.978384/-0.751678/-0.601683
  601.   z=pixel,tst=p1+4,t=1+pixel:
  602.    z=sqr(z)+t,
  603.     |z|<=tst
  604.   }
  605.  
  606. Gamma(XAXIS)={ ; first order gamma function from Prof. Jm
  607.   ; "It's pretty long to generate even on a 486-33 comp but there's a lot
  608.   ; of corners to zoom in and zoom and zoom...beautiful pictures :)"
  609.   z=pixel,twopi=6.283185307179586,r=10:
  610.    z=(twopi*z)^(0.5)*(z^z)*exp(-z)+pixel
  611.     |z|<=r
  612.   }
  613.  
  614. ZZ(XAXIS) { ; Prof Jm using Newton-Raphson method
  615.   ; use floating point with this one
  616.   z=pixel,solution=1:
  617.    z1=z^z;
  618.    z2=(log(z)+1)*z1;
  619.    z=z-(z1-1)/z2 ,
  620.     0.001 <= |solution-z1|
  621.   }
  622.  
  623. ZZa(XAXIS) { ; Prof Jm using Newton-Raphson method
  624.   ; use floating point with this one
  625.   z=pixel,solution=1:
  626.    z1=z^(z-1);
  627.    z2=(((z-1)/z)+log(z))*z1;
  628.    z=z-((z1-1)/z2) ,
  629.     .001 <= |solution-z1|
  630.   }
  631.  
  632.