home *** CD-ROM | disk | FTP | other *** search
/ Fractal Frenzy 2 / Fractal_Frenzy_Volume_II_Walnut_Creek_August_1995.iso / pc / formulas / frac2.frm < prev    next >
Encoding:
Text File  |  1993-04-23  |  28.7 KB  |  1,361 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.   ; Note that floating-point is required to make this compute accurately
  60.   z = pixel, Root = 1:
  61.    z3 = z*z*z;
  62.    z4 = z3 * z;
  63.    z = (3 * z4 + Root) / (4 * z3);
  64.     .004 <= |z4 - Root|
  65.   }
  66.  
  67. comment {
  68.    The following are from Chris Green:
  69.    These fractals all use Newton's or Halley's formula for approximation
  70.    of a function.  In all of these fractals, p1 real is the "relaxation
  71.    coefficient". A value of 1 gives the conventional newton or halley
  72.    iteration. Values <1 will generally produce less chaos than values >1.
  73.    1-1.5 is probably a good range to try.  P1 imag is the imaginary component
  74.    of the relaxation coefficient, and should be zero but maybe a small
  75.    non-zero value will produce something interesting. Who knows?
  76.    For more information on Halley maps, see "Computers, Pattern, Chaos,
  77.    and Beauty" by Pickover.
  78.    }
  79.  
  80. Halley (XYAXIS) {; Chris Green. Halley's formula applied to x^7-x=0.
  81.   ; P1 real usually 1 to 1.5, P1 imag usually zero. Use floating point.
  82.   ; Setting P1 to 1 creates the picture on page 277 of Pickover's book
  83.   z=pixel:
  84.    z5=z*z*z*z*z;
  85.    z6=z*z5;
  86.    z7=z*z6;
  87.    z=z-p1*((z7-z)/ ((7.0*z6-1)-(42.0*z5)*(z7-z)/(14.0*z6-2))),
  88.     0.0001 <= |z7-z|
  89.   }
  90.  
  91. CGhalley (XYAXIS) {; Chris Green -- Halley's formula
  92.   ; P1 real usually 1 to 1.5, P1 imag usually zero. Use floating point.
  93.   z=(1,1):
  94.    z5=z*z*z*z*z;
  95.    z6=z*z5;
  96.    z7=z*z6;
  97.    z=z-p1*((z7-z-pixel)/ ((7.0*z6-1)-(42.0*z5)*(z7-z-pixel)/(14.0*z6-2))),
  98.     0.0001 <= |z7-z-pixel|
  99.   }
  100.  
  101. halleySin (XYAXIS) {; Chris Green. Halley's formula applied to sin(x)=0.
  102.   ; Use floating point.
  103.   ; P1 real = 0.1 will create the picture from page 281 of Pickover's book.
  104.   z=pixel:
  105.    s=sin(z), c=cos(z)
  106.    z=z-p1*(s/(c-(s*s)/(c+c))),
  107.     0.0001 <= |s|
  108.   }
  109.  
  110. NewtonSinExp (XAXIS) {; Chris Green
  111.   ; Newton's formula applied to sin(x)+exp(x)-1=0.
  112.   ; Use floating point.
  113.   z=pixel:
  114.    z1=exp(z)
  115.    z2=sin(z)+z1-1
  116.    z=z-p1*z2/(cos(z)+z1),
  117.     .0001 < |z2|
  118.   }
  119.  
  120. CGNewton3 {; Chris Green -- A variation on newton iteration.
  121.   ; The initial guess is fixed at (1,1), but the equation solved
  122.   ; is different at each pixel ( x^3-pixel=0 is solved).
  123.   ; Use floating point.
  124.   ; Try P1=1.8.
  125.   z=(1,1):
  126.    z2=z*z;
  127.    z3=z*z2;
  128.    z=z-p1*(z3-pixel)/(3.0*z2),
  129.     0.0001 < |z3-pixel|
  130.   }
  131.  
  132. HyperMandel {; Chris Green.
  133.   ; A four dimensional version of the mandelbrot set.
  134.   ; Use P1 to select which two-dimensional plane of the
  135.   ; four dimensional set you wish to examine.
  136.   ; Use floating point.
  137.   a=(0,0),b=(0,0):
  138.    z=z+1
  139.    anew=sqr(a)-sqr(b)+pixel
  140.    b=2.0*a*b+p1
  141.    a=anew,
  142.     |a|+|b| <= 4
  143.   }
  144.  
  145.  
  146. MTet (XAXIS) {; Mandelbrot form 1 of the Tetration formula --Lee Skinner
  147.   z = pixel:
  148.    z = (pixel ^ z) + pixel,
  149.     |z| <= (P1 + 3)
  150.   }
  151.  
  152. AltMTet(XAXIS) {; Mandelbrot form 2 of the Tetration formula --Lee Skinner
  153.   z = 0:
  154.    z = (pixel ^ z) + pixel,
  155.     |z| <= (P1 + 3)
  156.   }
  157.  
  158. JTet (XAXIS) {; Julia form 1 of the Tetration formula --Lee Skinner
  159.   z = pixel:
  160.    z = (pixel ^ z) + P1,
  161.     |z| <= (P2 + 3)
  162.   }
  163.  
  164. AltJTet (XAXIS) {; Julia form 2 of the Tetration formula --Lee Skinner
  165.   z = P1:
  166.    z = (pixel ^ z) + P1,
  167.     |z| <= (P2 + 3)
  168.   }
  169.  
  170. Cubic (XYAXIS) {; Lee Skinner
  171.   p = pixel, test = p1 + 3,
  172.   t3 = 3*p, t2 = p*p,
  173.   a = (t2 + 1)/t3, b = 2*a*a*a + (t2 - 2)/t3,
  174.   aa3 = a*a*3, z = 0 - a :
  175.    z = z*z*z - aa3*z + b,
  176.     |z| < test
  177.  }
  178.  
  179.  
  180. { The following resulted from a FRACTINT bug. Version 13 incorrectly
  181.   calculated Spider (see above). We fixed the bug, and reverse-engineered
  182.   what it was doing to Spider - so here is the old "spider" }
  183.  
  184. Wineglass(XAXIS) {; Pieter Branderhorst
  185.   c = z = pixel:
  186.    z = z * z + c
  187.    c = (1+flip(imag(c))) * real(c) / 2 + z,
  188.     |z| <= 4 }
  189.  
  190.  
  191. { The following is from Scott Taylor.
  192.   Scott says they're "Dog" because the first one he looked at reminded him
  193.   of a hot dog. This was originally several fractals, we have generalized it. }
  194.  
  195. FnDog(XYAXIS)  {; Scott Taylor
  196.   z = Pixel, b = p1+2:
  197.    z = fn1( z ) * pixel,
  198.     |z| <= b
  199.   }
  200.  
  201. Ent {; Scott Taylor
  202.   ; Try params=.5/.75 and the first function as exp.
  203.   ; Zoom in on the swirls around the middle.  There's a
  204.   ; symmetrical area surrounded by an asymmetric area.
  205.   z = Pixel, y = fn1(z), base = log(p1):
  206.    z = y * log(z)/base,
  207.     |z| <= 4
  208.   }
  209.  
  210. Ent2 {; Scott Taylor
  211.   ; try params=2/1, functions=cos/cosh, potential=255/355
  212.   z = Pixel, y = fn1(z), base = log(p1):
  213.    z = fn2( y * log(z) / base ),
  214.     |z| <= 4
  215.   }
  216.  
  217. { From Kevin Lee: }
  218.  
  219. LeeMandel1(XYAXIS) {; Kevin Lee
  220.   z=Pixel:
  221. ;; c=sqr(pixel)/z, c=z+c, z=sqr(z),  this line was an error in v16
  222.    c=sqr(pixel)/z, c=z+c, z=sqr(c),
  223.     |z|<4
  224.   }
  225.  
  226. LeeMandel2(XYAXIS) {; Kevin Lee
  227.   z=Pixel:
  228.    c=sqr(pixel)/z, c=z+c, z=sqr(c*pixel),
  229.     |z|<4
  230.    }
  231.  
  232. LeeMandel3(XAXIS) {; Kevin Lee
  233.   z=Pixel, c=Pixel-sqr(z):
  234.    c=Pixel+c/z, z=c-z*pixel,
  235.     |z|<4
  236.   }
  237.  
  238. { These are a few of the examples from the book,
  239.   Fractal Creations, by Tim Wegner and Mark Peterson. }
  240.  
  241. MyFractal {; Fractal Creations example
  242.   c = z = 1/pixel:
  243.    z = sqr(z) + c;
  244.     |z| <= 4
  245.   }
  246.  
  247. Bogus1 {; Fractal Creations example
  248.   z = 0; z = z + * 2,
  249.    |z| <= 4 }
  250.  
  251. MandelTangent {; Fractal Creations example (revised for v.16)
  252.   z = pixel:
  253.    z = pixel * tan(z),
  254.     |real(z)| < 32
  255.   }
  256.  
  257. Mandel3 {; Fractal Creations example
  258.   z = pixel, c = sin(z):
  259.    z = (z*z) + c;
  260.    z = z * 1/c;
  261.     |z| <= 4;
  262.    }
  263.  
  264. { These are from: "AKA MrWizard W. LeRoy Davis;SM-ALC/HRUC"
  265.           davisl@sm-logdis1-aflc.af.mil
  266.   The first 3 are variations of:
  267.                z
  268.        gamma(z) = (z/e) * sqrt(2*pi*z) * R      }
  269.  
  270. Sterling(XAXIS) {; davisl
  271.   z = Pixel:
  272.    z = ((z/2.7182818)^z)/sqr(6.2831853*z),
  273.     |z| <= 4
  274.   }
  275.  
  276. Sterling2(XAXIS) {; davisl
  277.   z = Pixel:
  278.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) + pixel,
  279.     |z| <= 4
  280.   }
  281.  
  282. Sterling3(XAXIS) {; davisl
  283.   z = Pixel:
  284.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) - pixel,
  285.     |z| <= 4
  286.   }
  287.  
  288. PsudoMandel(XAXIS) {; davisl - try center=0,0/magnification=28
  289.   z = Pixel:
  290.    z = ((z/2.7182818)^z)*sqr(6.2831853*z) + pixel,
  291.     |z| <= 4
  292.   }
  293.  
  294. { These are the original "Richard" types sent by Jm Richard-Collard. Their
  295.   generalizations are tacked on to the end of the "Jm" list below, but
  296.   we felt we should keep these around for historical reasons.}
  297.  
  298. Richard1 (XYAXIS) {; Jm Richard-Collard
  299.   z = pixel:
  300.    sq=z*z, z=(sq*sin(sq)+sq)+pixel,
  301.     |z|<=50
  302.   }
  303.  
  304. Richard2 (XYAXIS) {; Jm Richard-Collard
  305.   z = pixel:
  306.    z=1/(sin(z*z+pixel*pixel)),
  307.     |z|<=50
  308.   }
  309.  
  310. Richard3 (XAXIS) {; Jm Richard-Collard
  311.   z = pixel:
  312.    sh=sinh(z), z=(1/(sh*sh))+pixel,
  313.     |z|<=50
  314.   }
  315.  
  316. Richard4 (XAXIS) {; Jm Richard-Collard
  317.   z = pixel:
  318.    z2=z*z, z=(1/(z2*cos(z2)+z2))+pixel,
  319.     |z|<=50
  320.   }
  321.  
  322. Richard5 (XAXIS) {; Jm Richard-Collard
  323.   z = pixel:
  324.    z=sin(z*sinh(z))+pixel,
  325.     |z|<=50
  326.   }
  327.  
  328. Richard6 (XYAXIS) {; Jm Richard-Collard
  329.   z = pixel:
  330.    z=sin(sinh(z))+pixel,
  331.     |z|<=50
  332.   }
  333.  
  334. Richard7 (XAXIS) {; Jm Richard-Collard
  335.   z=pixel:
  336.    z=log(z)*pixel,
  337.     |z|<=50
  338.   }
  339.  
  340. Richard8 (XYAXIS) {; Jm Richard-Collard
  341.   ; This was used for the "Fractal Creations" cover
  342.   z=pixel,sinp = sin(pixel):
  343.    z=sin(z)+sinp,
  344.     |z|<=50
  345.   }
  346.  
  347. Richard9 (XAXIS) {; Jm Richard-Collard
  348.   z=pixel:
  349.    sqrz=z*z, z=sqrz + 1/sqrz + pixel,
  350.     |z|<=4
  351.   }
  352.  
  353. Richard10(XYAXIS) {; Jm Richard-Collard
  354.   z=pixel:
  355.    z=1/sin(1/(z*z)),
  356.     |z|<=50
  357.   }
  358.  
  359. Richard11(XYAXIS) {; Jm Richard-Collard
  360.   z=pixel:
  361.    z=1/sinh(1/(z*z)),
  362.     |z|<=50
  363.   }
  364.  
  365. { These types are generalizations of types sent to us by the French
  366.   mathematician Jm Richard-Collard. If we hadn't generalized them
  367.   there would be --ahhh-- quite a few. With 11 possible values for
  368.   each fn variable,Jm_03, for example, has 14641 variations! }
  369.  
  370. Jm_01 {; generalized Jm Richard-Collard type
  371.   z=pixel,t=p1+4:
  372.    z=(fn1(fn2(z^pixel)))*pixel,
  373.     |z|<=t
  374.   }
  375.  
  376. Jm_02 {; generalized Jm Richard-Collard type
  377.   z=pixel,t=p1+4:
  378.    z=(z^pixel)*fn1(z^pixel),
  379.     |z|<=t
  380.   }
  381.  
  382. Jm_03 {; generalized Jm Richard-Collard type
  383.   z=pixel,t=p1+4:
  384.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))*pixel,
  385.     |z|<=t
  386.   }
  387.  
  388. Jm_03a {; generalized Jm Richard-Collard type
  389.   z=pixel,t=p1+4:
  390.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))+pixel,
  391.     |z|<=t
  392.   }
  393.  
  394. Jm_04 {; generalized Jm Richard-Collard type
  395.   z=pixel,t=p1+4:
  396.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel)),
  397.     |z|<=t
  398.   }
  399.  
  400. Jm_05 {; generalized Jm Richard-Collard type
  401.   z=pixel,t=p1+4:
  402.    z=fn1(fn2((z^pixel))),
  403.     |z|<=t
  404.   }
  405.  
  406. Jm_06 {; generalized Jm Richard-Collard type
  407.   z=pixel,t=p1+4:
  408.    z=fn1(fn2(fn3((z^z)*pixel))),
  409.     |z|<=t
  410.   }
  411.  
  412. Jm_07 {; generalized Jm Richard-Collard type
  413.   z=pixel,t=p1+4:
  414.    z=fn1(fn2(fn3((z^z)*pixel)))*pixel,
  415.     |z|<=t
  416.   }
  417.  
  418. Jm_08 {; generalized Jm Richard-Collard type
  419.   z=pixel,t=p1+4:
  420.    z=fn1(fn2(fn3((z^z)*pixel)))+pixel,
  421.     |z|<=t
  422.   }
  423.  
  424. Jm_09 {; generalized Jm Richard-Collard type
  425.   z=pixel,t=p1+4:
  426.    z=fn1(fn2(fn3(fn4(z))))+pixel,
  427.     |z|<=t
  428.   }
  429.  
  430. Jm_10 {; generalized Jm Richard-Collard type
  431.   z=pixel,t=p1+4:
  432.    z=fn1(fn2(fn3(fn4(z)*pixel))),
  433.     |z|<=t
  434.   }
  435.  
  436. Jm_11 {; generalized Jm Richard-Collard type
  437.   z=pixel,t=p1+4:
  438.    z=fn1(fn2(fn3(fn4(z)*pixel)))*pixel,
  439.     |z|<=t
  440.   }
  441.  
  442. Jm_11a {; generalized Jm Richard-Collard type
  443.   z=pixel,t=p1+4:
  444.    z=fn1(fn2(fn3(fn4(z)*pixel)))+pixel,
  445.     |z|<=t
  446.   }
  447.  
  448. Jm_12 {; generalized Jm Richard-Collard type
  449.   z=pixel,t=p1+4:
  450.    z=fn1(fn2(fn3(z)*pixel)),
  451.     |z|<=t
  452.   }
  453.  
  454. Jm_13 {; generalized Jm Richard-Collard type
  455.   z=pixel,t=p1+4:
  456.    z=fn1(fn2(fn3(z)*pixel))*pixel,
  457.     |z|<=t
  458.   }
  459.  
  460. Jm_14 {; generalized Jm Richard-Collard type
  461.   z=pixel,t=p1+4:
  462.    z=fn1(fn2(fn3(z)*pixel))+pixel,
  463.     |z|<=t
  464.   }
  465.  
  466. Jm_15 {; generalized Jm Richard-Collard type
  467.   z=pixel,t=p1+4:
  468.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))*pixel,
  469.     |z|<=t
  470.   }
  471.  
  472. Jm_16 {; generalized Jm Richard-Collard type
  473.   z=pixel,t=p1+4:
  474.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))+pixel,
  475.     |z|<=t
  476.   }
  477.  
  478. Jm_17 {; generalized Jm Richard-Collard type
  479.   z=pixel,t=p1+4:
  480.    z=fn1(z)*pixel*fn2(fn3(z)),
  481.     |z|<=t
  482.   }
  483.  
  484. Jm_18 {; generalized Jm Richard-Collard type
  485.   z=pixel,t=p1+4:
  486.    z=fn1(z)*pixel*fn2(fn3(z)*pixel),
  487.     |z|<=t
  488.   }
  489.  
  490. Jm_19 {; generalized Jm Richard-Collard type
  491.   z=pixel,t=p1+4:
  492.    z=fn1(z)*pixel*fn2(fn3(z)+pixel),
  493.     |z|<=t
  494.   }
  495.  
  496. Jm_20 {; generalized Jm Richard-Collard type
  497.   z=pixel,t=p1+4:
  498.    z=fn1(z^pixel),
  499.     |z|<=t
  500.   }
  501.  
  502. Jm_21 {; generalized Jm Richard-Collard type
  503.   z=pixel,t=p1+4:
  504.    z=fn1(z^pixel)*pixel,
  505.     |z|<=t
  506.   }
  507.  
  508. Jm_22 {; generalized Jm Richard-Collard type
  509.   z=pixel,t=p1+4:
  510.    sq=fn1(z), z=(sq*fn2(sq)+sq)+pixel,
  511.     |z|<=t
  512.   }
  513.  
  514. Jm_23 {; 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_24 {; generalized Jm Richard-Collard type
  521.   z=pixel,t=p1+4:
  522.    z2=fn1(z), z=(fn2(z2*fn3(z2)+z2))+pixel,
  523.     |z|<=t
  524.   }
  525.  
  526. Jm_25 {; generalized Jm Richard-Collard type
  527.   z=pixel,t=p1+4:
  528.    z=fn1(z*fn2(z)) + pixel,
  529.     |z|<=t
  530.   }
  531.  
  532. Jm_26 {; generalized Jm Richard-Collard type
  533.   z=pixel,t=p1+4:
  534.    z=fn1(fn2(z)) + pixel,
  535.     |z|<=t
  536.   }
  537.  
  538. Jm_27 {; generalized Jm Richard-Collard type
  539.   z=pixel,t=p1+4:
  540.    sqrz=fn1(z), z=sqrz + 1/sqrz + pixel,
  541.     |z|<=t
  542.   }
  543.  
  544. Jm_ducks(XAXIS) {; Jm Richard-Collard
  545.   ; Not so ugly at first glance and lot of corners to zoom in.
  546.   ; try this: corners=-1.178372/-0.978384/-0.751678/-0.601683
  547.   z=pixel,tst=p1+4,t=1+pixel:
  548.    z=sqr(z)+t,
  549.     |z|<=tst
  550.   }
  551.  
  552. Gamma(XAXIS)={ ; first order gamma function from Prof. Jm
  553.   ; "It's pretty long to generate even on a 486-33 comp but there's a lot
  554.   ; of corners to zoom in and zoom and zoom...beautiful pictures :)"
  555.   z=pixel,twopi=6.283185307179586,r=10:
  556.    z=(twopi*z)^(0.5)*(z^z)*exp(-z)+pixel
  557.     |z|<=r
  558.   }
  559.  
  560. ZZ(XAXIS) { ; Prof Jm using Newton-Raphson method
  561.   ; use floating point with this one
  562.   z=pixel,solution=1:
  563.    z1=z^z;
  564.    z2=(log(z)+1)*z1;
  565.    z=z-(z1-1)/z2 ,
  566.     0.001 <= |solution-z1|
  567.   }
  568.  
  569. ZZa(XAXIS) { ; Prof Jm using Newton-Raphson method
  570.   ; use floating point with this one
  571.   z=pixel,solution=1:
  572.    z1=z^(z-1);
  573.    z2=(((z-1)/z)+log(z))*z1;
  574.    z=z-((z1-1)/z2) ,
  575.     .001 <= |solution-z1|
  576.   }
  577.  
  578.  
  579. comment {
  580.   You should note that for the Transparent 3D fractals the x, y, z, and t
  581.   coordinates correspond to the 2D slices and not the final 3D True Color
  582.   image.  To relate the 2D slices to the 3D image, swap the x- and z-axis,
  583.   i.e. a 90 degree rotation about the y-axis.
  584.                 -Mark Peterson 6-2-91
  585.   }
  586.  
  587. MandelXAxis(XAXIS) {    ; for Transparent3D
  588.   z = zt,       ; Define Julia axes as depth/time and the
  589.   c = xy:       ;   Mandelbrot axes as width/height for each slice.
  590.             ;   This corresponds to Mandelbrot axes as
  591.             ;   height/depth and the Julia axes as width
  592.             ;   time for the 3D image.
  593.    z = Sqr(z) + c
  594.     LastSqr <= 4;
  595.   }
  596.  
  597. OldJulibrot(ORIGIN) {           ; for Transparent3D
  598.   z = real(zt) + flip(imag(xy)),    ; These settings coorespond to the
  599.   c = imag(zt) + flip(real(xy)):    ;   Julia axes as height/width and
  600.                     ;   the Mandelbrot axes as time/depth
  601.                     ;   for the 3D image.
  602.    z = Sqr(z) + c
  603.     LastSqr <= 4;
  604.   }
  605.    IkenagaMap(XAXIS) = {; based upon the Ikenaga function described
  606.       ; in Dewdneys's The Armchair Universe.
  607.       ; The initial starting point allows the function to provide a
  608.       ; "map" for the corresponding Julia function (Julike ) 
  609.       z = ((1-pixel)/3)^0.5: 
  610.       z = z*z*z + (pixel-1)*z - pixel, |z| <= 4
  611.    }
  612.  
  613.    Julike = {; a Julia function based upon the Ikenaga function
  614.       z = Pixel:
  615.       z = z*z*z + (P1-1)*z - P1, |z| <= 4
  616.    }
  617.  
  618.    Mask = {; try fn1 = log, fn2 = sinh, fn3 = cosh
  619.       ;P1 = (0,1), P2 = (0,1)
  620.       ;Use floating point
  621.       z = fn1(pixel):
  622.       z = P1*fn2(z)^2 + P2*fn3(z)^2 + pixel, |z| <= 4
  623.    }
  624.  
  625.    JMask = {      
  626.       z = fn1(pixel):
  627.       z = P1*fn2(z)^2 + P2, |z| <= 4
  628.    }
  629.  
  630.    PseudoZeePi = {
  631.       z = pixel:
  632.       x = 1-z^p1;
  633.       z = z*((1-x)/(1+x))^(1/p1) + p2, |z| <= 4
  634.    }
  635.  
  636.    ZeePi = {; This Julia function is based upon Ramanujan's iterative
  637.       ; function for calculating pi
  638.       z = pixel:
  639.       x = (1-z^p1)^(1/p1);
  640.       z = z*(1-x)/(1+x) + p2, |z| <= 4
  641.    }
  642.  
  643.    IkeNewtMand = {
  644.    z = c = pixel:
  645.    zf = z*z*z + (c-1)*z - c;
  646.    zd = 3*z*z + c-1;
  647.    z = z - p1*zf/zd, 0.001 <= |zf|
  648.    }
  649.  
  650.    IkeNewtJul = {
  651.    z =  pixel:
  652.    zf = z*z*z + (p2-1)*z - p2;
  653.    zd = 3*z*z + p2-1;
  654.    z = z - p1*zf/zd, 0.001 <= |zf|
  655.    }
  656.  
  657.    RecipIke = {
  658.    z = pixel:
  659.    z = 1/(z*z*z + (p1-1)*z - p1), |z| <= 4
  660.    }
  661.  
  662.    Frame-RbtM(XAXIS) = {; from Mazes for the Mind by Pickover
  663.    z = c = pixel:
  664.    z = z*z*z/5 + z*z + c, |z| <= 100
  665.    }
  666.  
  667.    Frame-RbtJ = {
  668.    z = pixel:
  669.    z = z*z*z/5 + z*z + p1, |z| <= 100
  670.    }
  671.  
  672.  comment = { SKINNER.FRM }
  673.  
  674.  Zexpe (XAXIS) = {
  675.       s = exp(1.,0.), z = Pixel:
  676.       z = z ^ s + pixel, |z| <= 100
  677.    }
  678.  
  679.  Zexpe2 (XAXIS) = {
  680.       s = exp(1.,0.), z = Pixel:
  681.       z = z ^ s + z ^ (s * pixel), |z| <= 100
  682.    }
  683.  
  684.  Ze2 (XAXIS) = {
  685.       s1 = exp(1.,0.),
  686.       s = s1 * s1,
  687.       z = Pixel:
  688.       z = z ^ s + pixel, |z| <= 100
  689.    }
  690.  
  691.  comment = {  s = log(-1.,0.) / (0.,1.)   is   (3.14159265358979, 0.0 }
  692.  
  693.  Exipi (XAXIS) = {
  694.       s = log(-1.,0.) / (0.,1.), z = Pixel:
  695.       z = z ^ s + pixel, |z| <= 100
  696.    }
  697.  
  698.  comment { version 13.0:}
  699.  LambdaLog(XAXIS) {
  700.       z = pixel, c = log(pixel):  
  701.          z = c * sqr(z) + pixel, 
  702.       |z| <= 4 
  703.    }
  704.  
  705.  comment { version 15.1:}
  706.  CGNewtonSinExp (XAXIS) {
  707.         z=pixel:
  708.         z1=exp(z);
  709.         z2=sin(z)+z1-z;
  710.         z=z-p1*z2/(cos(z)+z1), .0001 < |z2|
  711.    }
  712.  
  713.  OldManowar (XAXIS) {
  714.            z0 = 0,
  715.            z1 = 0,
  716.          test = p1 + 3,
  717.            c = pixel :
  718.                z = z1*z1 + z0 + c;
  719.                z0 = z1;
  720.                z1 = z,  |z| < test }
  721.  
  722.  comment { version 15.1:}
  723.  OldHalleySin (XYAXIS) {
  724.         z=pixel:
  725.         s=sin(z);
  726.         c=cosxx(z);
  727.         z=z-p1*(s/(c-(s*s)/(c+c))),
  728.         0.0001 <= |s|
  729.    }
  730.  
  731.  comment { version 15.1:}
  732.  OldCGNewtonSinExp (XAXIS) {
  733.         z=pixel:
  734.         z1=exp(z);
  735.         z2=sin(z)+z1-z;
  736.         z=z-p1*z2/(cosxx(z)+z1), .0001 < |z2|
  737.    }
  738.  
  739.  comment { version 15.1:}
  740.  OldNewtonSinExp (XAXIS) {; Chris Green
  741.   ; Newton's formula applied to sin(x)+exp(x)-1=0.
  742.   ; Use floating point.
  743.   z=pixel:
  744.    z1=exp(z)
  745.    z2=sin(z)+z1-1
  746.    z=z-p1*z2/(cosxx(z)+z1),
  747.     .0001 < |z2|
  748.   }
  749.  
  750.  comment { some of the following are included here because
  751.            BAILOUT=3 is still not supported}
  752.  
  753.  ScottLPC(XAXIS) { z = pixel, TEST = (p1+3): z = log(z)+cosxx(z), |z|<TEST }
  754.  
  755.  ScottLPS(XAXIS) { z = pixel, TEST = (p1+3): z = log(z)+sin(z), |z|<TEST }
  756.  
  757.  ScottLTC(XAXIS) { z = pixel, TEST = (p1+3): z = log(z)*cosxx(z), |z|<TEST }
  758.  
  759.  ScottLTS(XAXIS) { z = pixel, TEST = (p1+3): z = log(z)*sin(z), |z|<TEST }
  760.  
  761.  ScottSIC(XYAXIS) { z = pixel, TEST = (p1+3): z = sqr(1/cosxx(z)), |z|<TEST }
  762.  
  763.  ScSkCosH(XYAXIS) { z = pixel, TEST = (p1+3): z = cosh(z) - sqr(z), |z|<TEST }
  764.  
  765.  ScSkLMS(XAXIS) { z = pixel, TEST = (p1+3): z = log(z) - sin(z), |z|<TEST }
  766.  
  767.  ScSkZCZZ(XYAXIS) { z = pixel, TEST = (p1+3): z = (z*cosxx(z)) - z, |z|<TEST }
  768.  
  769. comment {
  770. This file includes the formulas required to support the file
  771. RCLPAR.PAR.
  772.  
  773. In addition, I have included a number of additional formulas 
  774. for your enjoyment <G>.
  775.  
  776. Ron Lewen
  777. CIS: 76376,2567 
  778.  
  779.   }
  780.  
  781. RCL_Cosh (XAXIS) { ; Ron Lewen, 76376,2567
  782.   ; Try corners=2.008874/-3.811126/-3.980167/3.779833/
  783.   ; -3.811126/3.779833 to see Figure 9.7 (P. 123) in 
  784.   ; Pickover's Computers, Pattern, Chaos and Beauty.
  785.   ; Figures 9.9 - 9.13 can be found by zooming.
  786.   ; Use floating point
  787.   ;
  788.   z=0:
  789.     z=cosh(z) + pixel,
  790.       abs(z) < 40
  791.   }
  792.  
  793. Mothra (XAXIS) { ; Ron Lewen, 76376,2567
  794.   ; Remember Mothra, the giant Japanese-eating moth?
  795.   ; Well... here he (she?) is as a fractal!
  796.   ;
  797.   z=pixel:
  798.     z2=z*z
  799.     z3=z2*z
  800.     z4=z3*z
  801.     a=z4*z + z3 + z + pixel
  802.     b=z4 + z2 + pixel
  803.     z=b*b/a,
  804.       |real(z)| <= 100 || |imag(z)| <= 100
  805.   }
  806.  
  807. RCL_11 { ; Ron Lewen, 76376,2567
  808.   ; A variation on the formula used to generate
  809.   ; Figure 9.18 (p. 134) from Pickover's book.
  810.   ; P1 sets the initial value for z.
  811.   ; Try p1=.75, or p1=2, or just experiment!
  812.   ;
  813.   z=real(p1):
  814.     z=z*pixel-pixel/sqr(z)
  815.     z=flip(z),
  816.       abs(z) < 8
  817.   }
  818.  
  819. RCL_10 { ; Ron Lewen, 76376,2567
  820.   ;
  821.   ;
  822.   ;
  823.   z=pixel:
  824.     z=flip((z*z+pixel)/(pixel*pixel+z))
  825.       |z| <= 4
  826.   }
  827.  
  828. { Spectacular! }
  829.    FractalFenderC(XAXIS_NOPARM) {z=p1,x=|z|:
  830.        (z=cosh(z)+pixel)*(1<x)+(z=z)*(x<=1),
  831.        z=sqr(z)+pixel,x=|z|,
  832.        x<=4 }
  833.  
  834.    SpecC(XAXIS_NOPARM) {z=p1,x=|z|:
  835.        (z=fn1(z)+pixel)*(1<x)+(z=z)*(x<=1),
  836.        z=fn2(z)+pixel,x=|z|,
  837.        x<=4 }
  838.  
  839.  Silverado(XAXIS) {; Rollo Silver
  840.   ; Select p1 such that 0. <= p1 <= 1.
  841.   z = Pixel, zz=z*z, zzz=zz*z, z = (1.-p1)*zz + (p1*zzz), test = (p2+4)*(p2+4): ;
  842.    z = z + Pixel
  843.    zsq = z*z
  844.    zcu = zsq*z
  845.    z = (1.-p1)*zsq + p1*zcu,
  846.    |z| <= test
  847.   }
  848.  
  849.  comment = { Moire Tetrated Log - Improper Bailout }
  850.  
  851.  TLog (XAXIS) = {
  852.         z = c = log(pixel):
  853.                 z = c ^ z,
  854.                     z <= (p1 + 3)
  855.         }
  856.  
  857.  comment = { Tetrated Hyperbolic Sine - Improper Bailout }
  858.  
  859.  TSinh (XAXIS) = {
  860.         z = c = sinh(pixel):
  861.                 z = c ^ z,
  862.                     z <= (p1 + 3)
  863.         }
  864.  
  865.  DrChaosbrot2(xyaxis)   { ;more phi
  866.  
  867.  z = c = pixel:
  868.  z = sqr(z) + (((sqrt 5 + 1)/2)+c)
  869.  |z| <= 4;
  870.  }
  871.  
  872. phoenix_m { ; Mandelbrot stye map of the Phoenix curves
  873.    z=x=y=nx=ny=x1=y1=x2=y2=0:
  874.    x2 = sqr(x), y2 = sqr(y),
  875.    x1 = x2 - y2 + real(pixel) + imag(pixel) * nx,
  876.    y1 = 2 * x * y + imag(pixel) * ny,
  877.    nx=x, ny=y, x=x1, y=y1, z=x + flip(y),
  878.    |z| <= 4
  879.    }
  880.  
  881.  ScottSIS(XYAXIS) { z = pixel, TEST = (p1+3): z = sqr(1/sin(z)), |z|<TEST }
  882.  
  883. M-SetInNewton(XAXIS) {; use float=yes
  884.                       ; jon horner 100112,1700, 12 feb 93
  885.   z = 0,  c = pixel,  cminusone = c-1:
  886.   oldz = z,  nm = 3*c-2*z*cminusone, dn = 3*(3*z*z+cminusone),
  887.   z = nm/dn+2*z/3,   |(z-oldz)|>=|0.01|
  888.  }
  889.  
  890. ;========================================================================
  891. ;Date:    Mon, 10 Feb 1992 13:10:12 EST
  892. ;From: "Bruno"
  893. ;Subject: MORE .par and .frm
  894. ;X-Topic: Entry #3185 of LISTS.FRAC-L
  895. ;To: "LISTS.FRAC-L.3185"
  896. ;
  897. ;Posted on 10 Feb 1992 at 12:24:22 by BrownVM Mailer (103837)
  898. ;
  899. ;MORE .par and .frm
  900. ;
  901. ;Date:         Mon, 10 Feb 1992 08:18:36 GMT
  902. ;Reply-To:     'FRACTAL' discussion list <FRAC-L@GITVM1.BITNET>
  903. ;From:         Rob den Braasem <rdb@KTIBV.UUCP>
  904. ;
  905. ;Here are a group of files with formulas derived from a book of Roger Stevens
  906. ;
  907. ;First the formmats file and then the par file.
  908. ;
  909. ;
  910. ;--------------------------------------------------------------------
  911. ;{
  912. ;  ADVANCE FRACTAL PROGRAMMING IN C
  913. ;  by Roger Stevens.
  914. ;
  915. ;  I changed them in a Julia and Mandelbrot type fractal generatoren.
  916. ;  The Graphical Gnome (rdb@ktibv)
  917. ;
  918. ;}
  919. ;
  920. ;{
  921. ;   JULIA TYPE FRACTALS
  922. ;}
  923. ;
  924.  
  925. J_TchebychevT2 {
  926.    c = pixel, z = P1:
  927.    z = c*(2*z*z-1),
  928.    |z|<100
  929. }
  930.  
  931. J_TchebychevT3 {   ;
  932.    c = pixel, z = P1:
  933.    z = c*z*(4*z*z-3),
  934.    |z|<100
  935. }
  936.  
  937. J_TchebychevT4 {
  938.    c = pixel, z = P1:
  939.    z = c*(z*z*(8*z*z+8)+1),
  940.    |z|<100
  941. }
  942.  
  943. J_TchebychevT5 {    ;
  944.    c = pixel, z = P1:
  945.    z = c*(z*(z*z*(16*z*z-20)+5)),
  946.    |z|<100
  947. }
  948.  
  949. J_TchebychevT6 {
  950.    c = pixel, z = P1:
  951.    z = c*(z*z*(z*z*(32*z*z-48)+18)-1),
  952.    |z|<100
  953. }
  954.  
  955. J_TchebychevT7 {     ;
  956.    c = pixel, z = P1:
  957.    z = c*z*(z*z*(z*z*(64*z*z-112)+56)-7),
  958.    |z|<100
  959. }
  960.  
  961. J_TchebychevC2 {
  962.    c = pixel, z = P1:
  963.    z = c*(z*z-2),
  964.    |z|<100
  965. }
  966.  
  967. J_TchebychevC3 {   ;
  968.    c = pixel, z = P1:
  969.    z = c*z*(z*z-3),
  970.    |z|<100
  971. }
  972.  
  973. J_TchebychevC4 {
  974.    c = pixel, z = P1:
  975.    z = c*(z*z*(z*z-4)+2),
  976.    |z|<100
  977. }
  978.  
  979. J_TchebychevC5 {    ;
  980.    c = pixel, z = P1:
  981.    z = c*z*(z*z*(z*z-5)+5),
  982.    |z|<100
  983. }
  984.  
  985. J_TchebychevC6 {
  986.    c = pixel, z = P1:
  987.    z = c*(z*z*(z*z*(z*z-6)+9)-2),
  988.    |z|<100
  989. }
  990.  
  991. J_TchebychevC7 {     ;
  992.    c = pixel, z = P1:
  993.    z = c*z*(z*z*(z*z*(z*z-7)+14)-7),
  994.    |z|<100
  995. }
  996.  
  997.  
  998. J_TchebychevU2 {
  999.    c = pixel, z = P1:
  1000.    z = c*(4*z*z-1),
  1001.    |z|<100
  1002. }
  1003.  
  1004. J_TchebychevU3 {   ;
  1005.    c = pixel, z = P1:
  1006.    z = c*z*(8*z*z-4),
  1007.    |z|<100
  1008. }
  1009.  
  1010. J_TchebychevU4 {
  1011.    c = pixel, z = P1:
  1012.    z = c*(z*z*(16*z*z-12)+1),
  1013.    |z|<100
  1014. }
  1015.  
  1016. J_TchebychevU5 {    ;
  1017.    c = pixel, z = P1:
  1018.    z = c*z*(z*z*(32*z*z-32)+6),
  1019.    |z|<100
  1020. }
  1021.  
  1022. J_TchebychevU6 {
  1023.    c = pixel, z = P1:
  1024.    z = c*(z*z*(z*z*(64*z*z-80)+24)-1),
  1025.    |z|<100
  1026. }
  1027.  
  1028. J_TchebychevU7 {     ;
  1029.    c = pixel, z = P1:
  1030.    z = c*z*(z*z*(z*z*(128*z*z-192)+80)-8),
  1031.    |z|<100
  1032. }
  1033.  
  1034. J_TchebychevS2 {
  1035.    c = pixel, z = P1:
  1036.    z = c*(z*z-1),
  1037.    |z|<100
  1038. }
  1039.  
  1040. J_TchebychevS3 {   ;
  1041.    c = pixel, z = P1:
  1042.    z = c*z*(z*z-2),
  1043.    |z|<100
  1044. }
  1045.  
  1046. J_TchebychevS4 {
  1047.    c = pixel, z = P1:
  1048.    z = c*(z*z*(z*z-3)+1),
  1049.    |z|<100
  1050. }
  1051.  
  1052. J_TchebychevS5 {    ;
  1053.    c = pixel, z = P1:
  1054.    z = c*z*(z*z*(z*z-4)+3),
  1055.    |z|<100
  1056. }
  1057.  
  1058. J_TchebychevS6 {
  1059.    c = pixel, z = P1:
  1060.    z = c*(z*z*(z*z*(z*z-5)+6)-1),
  1061.    |z|<100
  1062. }
  1063.  
  1064. J_TchebychevS7 {     ;
  1065.    c = pixel, z = P1:
  1066.    z = c*z*(z*z*(z*z*(z*z-6)+10)-4),
  1067.    |z|<100
  1068. }
  1069.  
  1070. J_Laguerre2 {
  1071.    c = pixel, z = P1:
  1072.    z = (z*(z - 4) +2 ) / 2 + c,
  1073.    |z| < 100
  1074.  
  1075. }
  1076.  
  1077. J_Laguerre3 {
  1078.    c = pixel, z = P1:
  1079.    z = (z*(z*(-z + 9) -18) + 6 ) / 6 + c,
  1080.    |z| < 100
  1081. }
  1082.  
  1083. J_Laguerre4 {
  1084.    c = pixel, z = P1:
  1085.    z = (z * ( z * ( z * ( z - 16)+ 72) - 96)+ 24 ) / 24 + c,
  1086.    |z| < 100
  1087. }
  1088.  
  1089. J_Laguerre5 {
  1090.    c = pixel, z = P1:
  1091.    z = (z * ( z * ( z * ( z * (-z +25) -200) +600) -600) + 120 ) / 120 + c,
  1092.    |z| < 100
  1093. }
  1094.  
  1095. J_Laguerre6 {
  1096.    c = pixel, z = P1:
  1097.    z = (z * ( z * ( z * ( z*(z*(z -36) +450) -2400) + 5400)-4320) + 720 ) / 720
  1098. + c,
  1099.    |z| < 100
  1100. }
  1101.  
  1102. J_Lagandre2 {
  1103.    c = pixel, z = P1:
  1104.    z = (3 * z*z - 1) / 2 + c
  1105.    |z| < 100
  1106. }
  1107.  
  1108. J_Lagandre3 {
  1109.    c = pixel, z = P1:
  1110.    z = z * (5 * z*z - 3) / 2 + c
  1111.    |z| < 100
  1112. }
  1113.  
  1114. J_Lagandre4 {
  1115.    c = pixel, z = P1:
  1116.    z = (z*z*(35 * z*z - 30) + 3) / 8 + c
  1117.    |z| < 100
  1118. }
  1119.  
  1120. J_Lagandre5 {
  1121.    c = pixel, z = P1:
  1122.    z = z* (z*z*(63 * z*z - 70) + 15 ) / 8 + c
  1123.    |z| < 100
  1124. }
  1125.  
  1126. J_Lagandre6 {
  1127.    c = pixel, z = P1:
  1128.    z = (z*z*(z*z*(231 * z*z - 315)  + 105 ) - 5) / 16 + c
  1129.    |z| < 100
  1130. }
  1131.  
  1132. J_Lagandre7 {
  1133.    c = pixel, z = P1:
  1134.    z = z* (z*z*(z*z*(429 * z*z - 693) + 315) - 35 ) / 16 + c
  1135.    |z| < 100
  1136. }
  1137.  
  1138. {
  1139.  MANDELBROT TYPE FRACTALS
  1140. }
  1141.  
  1142. M_TchebychevT2 {
  1143.    c = P1, z = Pixel:
  1144.    z = c*(2*z*z-1),
  1145.    |z|<100
  1146. }
  1147.  
  1148. M_TchebychevT3 {   ;
  1149.    c = P1, z = Pixel:
  1150.    z = c*z*(4*z*z-3),
  1151.    |z|<100
  1152. }
  1153.  
  1154. M_TchebychevT4 {
  1155.    c = P1, z = Pixel:
  1156.    z = c*(z*z*(8*z*z+8)+1),
  1157.    |z|<100
  1158. }
  1159.  
  1160. M_TchebychevT5 {    ;
  1161.    c = P1, z = Pixel:
  1162.    z = c*(z*(z*z*(16*z*z-20)+5)),
  1163.    |z|<100
  1164. }
  1165.  
  1166. M_TchebychevT6 {
  1167.    c = P1, z = Pixel:
  1168.    z = c*(z*z*(z*z*(32*z*z-48)+18)-1),
  1169.    |z|<100
  1170. }
  1171.  
  1172. M_TchebychevT7 {     ;
  1173.    c = P1, z = Pixel:
  1174.    z = c*z*(z*z*(z*z*(64*z*z-112)+56)-7),
  1175.    |z|<100
  1176. }
  1177.  
  1178. M_TchebychevC2 {
  1179.    c = P1, z = Pixel:
  1180.    z = c*(z*z-2),
  1181.    |z|<100
  1182. }
  1183.  
  1184. M_TchebychevC3 {   ;
  1185.    c = P1, z = Pixel:
  1186.    z = c*z*(z*z-3),
  1187.    |z|<100
  1188. }
  1189.  
  1190. M_TchebychevC4 {
  1191.    c = P1, z = Pixel:
  1192.    z = c*(z*z*(z*z-4)+2),
  1193.    |z|<100
  1194. }
  1195.  
  1196. M_TchebychevC5 {    ;
  1197.    c = P1, z = Pixel:
  1198.    z = c*z*(z*z*(z*z-5)+5),
  1199.    |z|<100
  1200. }
  1201.  
  1202. M_TchebychevC6 {
  1203.    c = P1, z = Pixel:
  1204.    z = c*(z*z*(z*z*(z*z-6)+9)-2),
  1205.    |z|<100
  1206. }
  1207.  
  1208. M_TchebychevC7 {     ;
  1209.    c = P1, z = Pixel:
  1210.    z = c*z*(z*z*(z*z*(z*z-7)+14)-7),
  1211.    |z|<100
  1212. }
  1213.  
  1214.  
  1215. M_TchebychevU2 {
  1216.    c = P1, z = Pixel:
  1217.    z = c*(4*z*z-1),
  1218.    |z|<100
  1219. }
  1220.  
  1221. M_TchebychevU3 {   ;
  1222.    c = P1, z = Pixel:
  1223.    z = c*z*(8*z*z-4),
  1224.    |z|<100
  1225. }
  1226.  
  1227. M_TchebychevU4 {
  1228.    c = P1, z = Pixel:
  1229.    z = c*(z*z*(16*z*z-12)+1),
  1230.    |z|<100
  1231. }
  1232.  
  1233. M_TchebychevU5 {    ;
  1234.    c = P1, z = Pixel:
  1235.    z = c*z*(z*z*(32*z*z-32)+6),
  1236.    |z|<100
  1237. }
  1238.  
  1239. M_TchebychevU6 {
  1240.    c = P1, z = Pixel:
  1241.    z = c*(z*z*(z*z*(64*z*z-80)+24)-1),
  1242.    |z|<100
  1243. }
  1244.  
  1245. M_TchebychevU7 {     ;
  1246.    c = P1, z = Pixel:
  1247.    z = c*z*(z*z*(z*z*(128*z*z-192)+80)-8),
  1248.    |z|<100
  1249. }
  1250.  
  1251. M_TchebychevS2 {
  1252.    c = P1, z = Pixel:
  1253.    z = c*(z*z-1),
  1254.    |z|<100
  1255. }
  1256.  
  1257. M_TchebychevS3 {   ;
  1258.    c = P1, z = Pixel:
  1259.    z = c*z*(z*z-2),
  1260.    |z|<100
  1261. }
  1262.  
  1263. M_TchebychevS4 {
  1264.    c = P1, z = Pixel:
  1265.    z = c*(z*z*(z*z-3)+1),
  1266.    |z|<100
  1267. }
  1268.  
  1269. M_TchebychevS5 {    ;
  1270.    c = P1, z = Pixel:
  1271.    z = c*z*(z*z*(z*z-4)+3),
  1272.    |z|<100
  1273. }
  1274.  
  1275. M_TchebychevS6 {
  1276.    c = P1, z = Pixel:
  1277.    z = c*(z*z*(z*z*(z*z-5)+6)-1),
  1278.    |z|<100
  1279. }
  1280.  
  1281. M_TchebychevS7 {     ;
  1282.    c = P1, z = Pixel:
  1283.    z = c*z*(z*z*(z*z*(z*z-6)+10)-4),
  1284.    |z|<100
  1285. }
  1286.  
  1287. M_Laguerre2 {
  1288.    c = P1, z = Pixel:
  1289.    z = (z*(z - 4) +2 ) / 2 + c,
  1290.    |z| < 100
  1291.  
  1292. }
  1293.  
  1294. M_Laguerre3 {
  1295.    c = P1, z = Pixel:
  1296.    z = (z*(z*(-z + 9) -18) + 6 ) / 6 + c,
  1297.    |z| < 100
  1298. }
  1299.  
  1300. M_Laguerre4 {
  1301.    c = P1, z = Pixel:
  1302.    z = (z * ( z * ( z * ( z - 16)+ 72) - 96)+ 24 ) / 24 + c,
  1303.    |z| < 100
  1304. }
  1305.  
  1306. M_Laguerre5 {
  1307.    c = P1, z = Pixel:
  1308.    z = (z * ( z * ( z * ( z * (-z +25) -200) +600) -600) + 120 ) / 120 + c,
  1309.    |z| < 100
  1310. }
  1311.  
  1312. M_Laguerre6 {
  1313.    c = P1, z = Pixel:
  1314.    z = (z * ( z * ( z * ( z*(z*(z -36) +450) -2400) + 5400)-4320) + 720 ) / 720
  1315. + c,
  1316.    |z| < 100
  1317. }
  1318.  
  1319. M_Lagandre2 {
  1320.    c = P1, z = Pixel:
  1321.    z = (3 * z*z - 1) / 2 + c
  1322.    |z| < 100
  1323. }
  1324.  
  1325. M_Lagandre3 {
  1326.    c = P1, z = Pixel:
  1327.    z = z * (5 * z*z - 3) / 2 + c
  1328.    |z| < 100
  1329. }
  1330.  
  1331. M_Lagandre4 {
  1332.    c = P1, z = Pixel:
  1333.    z = (z*z*(35 * z*z - 30) + 3) / 8 + c
  1334.    |z| < 100
  1335. }
  1336.  
  1337. M_Lagandre5 {
  1338.    c = P1, z = Pixel:
  1339.    z = z* (z*z*(63 * z*z - 70) + 15 ) / 8 + c
  1340.    |z| < 100
  1341. }
  1342.  
  1343. M_Lagandre6 {
  1344.    c = P1, z = Pixel:
  1345.    z = (z*z*(z*z*(231 * z*z - 315)  + 105 ) - 5) / 16 + c
  1346.    |z| < 100
  1347. }
  1348.  
  1349. M_Lagandre7 {
  1350.    c = P1, z = Pixel:
  1351.    z = z* (z*z*(z*z*(429 * z*z - 693) + 315) - 35 ) / 16 + c
  1352.    |z| < 100
  1353. }
  1354.  
  1355. test{
  1356.   z=pixel,c=p1:
  1357.    c = P1, z = Pixel:
  1358.    z = z* (z*z*(z*z*(429 * z*z - 693) + 315) - 35 ) / (16 * (z+c))
  1359.    |z| < 100
  1360. }
  1361.