home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 November / Chip_2001-11_cd1.bin / sharewar / chaospro / cpro302.exe / GFP.CFM < prev    next >
Encoding:
Text File  |  2001-07-04  |  207.4 KB  |  10,189 lines
  1. comment {
  2. Formulas by Gedeon Peteri, 1997-2000
  3. http://www.geocities.com/gedeonp/fractals/frindex.html
  4. gedeon@infoave.net
  5.  
  6. This file is a compilation of previously
  7. published formula files
  8. gfpcurves.ufm
  9. gfpeuler.ufm
  10. gfpfrc.ufm
  11. chbymod.ufm
  12. and previously unpublished additions.
  13.  
  14. Updated: October 1, 2000
  15.  
  16. gpm- prefix denotes formulas which are my
  17. translations to UF format, with slight
  18. modifications, of Fractint formulas by
  19. other authors, as commented in the formulas.
  20. In all cases such modifications are limited
  21. to the addition of a function to the initiation
  22. section; turning hard coded functions and
  23. parameters into user definable ones, with the
  24. original values used as defaults; adding a
  25. bailout test parameter. In no case did I
  26. change the loop section of any formula.
  27. }
  28.  
  29.  
  30. comment
  31. {
  32. ;------------------------------------------------------------------------
  33.  
  34. ;Formulas loosely based on the equations
  35. ;of some classic curves as found in any
  36. ;textbook of elementary analytic geometry.
  37. ;Please note that I have taken a great deal
  38. ;of liberty with the mathematics! Pleasing
  39. ;images, not correct mathematical representation,
  40. ;was the goal.
  41.  
  42. ;The equation of the CATENARY is
  43. ;y=a/2*(e^(x/a) + e^-(x/a))
  44.  
  45.  
  46. }
  47.  
  48. gfpcat01    {//Formula by Gedeon Peteri, 1999
  49.              //Based on equation of Catenary
  50. parameter complex p1;
  51. parameter complex p3;
  52. parameter complex p2;
  53. parameter real bailout;
  54.  
  55.     void init(void)
  56.     {
  57.         z=fn1(pixel);
  58.     }
  59.     void loop(void)
  60.     {
  61.         z=fn2(z^p1) - p3*(fn3(p2/2*(exp(z/p2)+1/exp(z/p2))));
  62.     }
  63.     bool bailout(void)
  64.     {
  65.         return(|z|<=bailout);
  66.     }
  67.     void description(void)
  68.     {
  69.         this.title="gfpcat01";
  70.  
  71.         p1.caption="Exponent";
  72.         p1.default=(1.0,0.0);
  73.    
  74.  
  75.         p2.caption="Parameter 1";
  76.         p2.default=(1.0,0.0);
  77.    
  78.  
  79.         p3.caption="Parameter 2";
  80.         p3.default=(1.0,0.0);
  81.    
  82.  
  83.         bailout.caption="Bailout";
  84.         bailout.default=4.0;
  85.    
  86.  
  87.         fn1.caption="Function 1";
  88.         fn1.default = "ident" ;
  89.   
  90.  
  91.         fn2.caption="Function 2";
  92.         fn2.default = "ident" ;
  93.   
  94.  
  95.         fn3.caption="Function 3";
  96.         fn3.default = "ident" ;
  97.   
  98.     }
  99. }
  100.  
  101.  
  102. comment
  103. {
  104. ;The parametric equations of the CAUSTIC are
  105. ;x=3/4 cos(t) - 1/4 cos(3t); y=3/4 sin(t) - 1/4 sin(3t)
  106.  
  107.  
  108. }
  109.  
  110. gfpcau01    {//Formula by Gedeon Peteri, 1999
  111.              //Based on equation of Caustic
  112. complex c;
  113. complex Var_x;
  114. complex Var_y;
  115. parameter complex p1;
  116. parameter complex p2;
  117. parameter real bailout;
  118.  
  119.     void init(void)
  120.     {
  121.         z=fn1(pixel);
  122.     }
  123.     void loop(void)
  124.     {
  125.         c=asin(imag(z)/cabs(z));
  126.         Var_x=.75*cos(c)-.25*cos(3*c);
  127.         Var_y=.75*sin(c)-.25*sin(3*c);
  128.         z=fn2(z^p1)+p2*fn3(Var_x-flip(Var_y));
  129.     }
  130.     bool bailout(void)
  131.     {
  132.         return(|z|<=bailout);
  133.     }
  134.     void description(void)
  135.     {
  136.         this.title="gfpcau01";
  137.  
  138.         p1.caption="Exponent";
  139.         p1.default=(1.0,0.0);
  140.    
  141.  
  142.         p2.caption="Parameter";
  143.         p2.default=(1.0,0.0);
  144.    
  145.  
  146.         bailout.caption="Bailout";
  147.         bailout.default=4.0;
  148.    
  149.  
  150.         fn1.caption="Function 1";
  151.         fn1.default = "ident" ;
  152.   
  153.  
  154.         fn2.caption="Function 2";
  155.         fn2.default = "ident" ;
  156.   
  157.  
  158.         fn3.caption="Function 3";
  159.         fn3.default = "ident" ;
  160.   
  161.     }
  162. }
  163.  
  164.  
  165. gfpcau02    {//Formula by Gedeon Peteri, 1999
  166.              //Based on equation of Caustic
  167. complex c;
  168. complex Var_x;
  169. complex Var_y;
  170. parameter complex p1;
  171. parameter complex p2;
  172. parameter real bailout;
  173.  
  174.     void init(void)
  175.     {
  176.         z=fn1(pixel);
  177.     }
  178.     void loop(void)
  179.     {
  180.         c=asin(imag(z)/cabs(z));
  181.         Var_x=.75*cos(c)-.25*cos(3*c);
  182.         Var_y=.75*sin(c)-.25*sin(3*c);
  183.         z=fn2(z^p1)+p2*fn3(Var_y-flip(Var_x));
  184.     }
  185.     bool bailout(void)
  186.     {
  187.         return(|z|<=bailout);
  188.     }
  189.     void description(void)
  190.     {
  191.         this.title="gfpcau02";
  192.  
  193.         p1.caption="Exponent";
  194.         p1.default=(1.0,0.0);
  195.    
  196.  
  197.         p2.caption="Parameter";
  198.         p2.default=(1.0,0.0);
  199.    
  200.  
  201.         bailout.caption="Bailout";
  202.         bailout.default=4.0;
  203.    
  204.  
  205.         fn1.caption="Function 1";
  206.         fn1.default = "ident" ;
  207.   
  208.  
  209.         fn2.caption="Function 2";
  210.         fn2.default = "ident" ;
  211.   
  212.  
  213.         fn3.caption="Function 3";
  214.         fn3.default = "ident" ;
  215.   
  216.     }
  217. }
  218.  
  219.  
  220. comment
  221. {
  222. ;The equation of the CISSOID OF DIOCLES is
  223. ;y^2=x^3/(2a-x), or y=+/- (x^3/(2a-x))^.5
  224.  
  225.  
  226. }
  227.  
  228. gfpcod01    {//Formula by Gedeon Peteri, 1999
  229.              //Based on equation of Cissoid of Diocles
  230. complex Var_x;
  231. parameter complex p1;
  232. complex Var_y;
  233. parameter complex p3;
  234. parameter complex p2;
  235. parameter real bailout;
  236.  
  237.     void init(void)
  238.     {
  239.         z=fn1(pixel);
  240.     }
  241.     void loop(void)
  242.     {
  243.         Var_x=sqrt(z^3/(p1-z));
  244.         Var_y=-sqrt(z^3/(p1-z));
  245.         z=fn2(z^p3) + p2*(fn3(Var_x) + fn4(Var_y));
  246.     }
  247.     bool bailout(void)
  248.     {
  249.         return(|z|<=bailout);
  250.     }
  251.     void description(void)
  252.     {
  253.         this.title="gfpcod01";
  254.  
  255.         p1.caption="Parameter 1";
  256.         p1.default=(1.0,0.0);
  257.    
  258.  
  259.         p2.caption="Parameter 2";
  260.         p2.default=(1.0,0.0);
  261.    
  262.  
  263.         p3.caption="Exponent";
  264.         p3.default=(2.0,0.0);
  265.    
  266.  
  267.         bailout.caption="Bailout";
  268.         bailout.default=4.0;
  269.    
  270.  
  271.         fn1.caption="Function 1";
  272.         fn1.default = "ident" ;
  273.   
  274.  
  275.         fn2.caption="Function 2";
  276.         fn2.default = "ident" ;
  277.   
  278.  
  279.         fn3.caption="Function 3";
  280.         fn3.default = "ident" ;
  281.   
  282.  
  283.         fn4.caption="Function 4";
  284.         fn4.default = "ident" ;
  285.   
  286.     }
  287. }
  288.  
  289.  
  290. comment
  291. {
  292. ;The polar equation of the CONCHOID OF NICOMEDES is
  293. ;r=a*sec(t) +/- b;  [sec=1/cos]
  294.  
  295.  
  296. }
  297.  
  298. gfpcon01    {//Formula by Gedeon Peteri, 1999
  299.              //Based on equation of Conchoid of Nicomedes
  300. complex c;
  301. complex Var_x;
  302. parameter complex p1;
  303. complex Var_y;
  304. parameter complex p3;
  305. parameter complex p2;
  306. parameter real bailout;
  307.  
  308.     void init(void)
  309.     {
  310.         z=fn1(pixel);
  311.     }
  312.     void loop(void)
  313.     {
  314.         c=asin(imag(z)/cabs(z));
  315.         Var_x=z*1/cos(c)+p1;
  316.         Var_y=z*1/cos(c)-p1;
  317.         z=fn2(z^p3) + p2*fn3(Var_x)*fn4(Var_y);
  318.     }
  319.     bool bailout(void)
  320.     {
  321.         return(|z|<=bailout);
  322.     }
  323.     void description(void)
  324.     {
  325.         this.title="gfpcon01";
  326.  
  327.         p1.caption="Parameter 1";
  328.         p1.default=(1.0,0.0);
  329.    
  330.  
  331.         p2.caption="Parameter 2";
  332.         p2.default=(1.0,0.0);
  333.    
  334.  
  335.         p3.caption="Exponent";
  336.         p3.default=(2.0,0.0);
  337.    
  338.  
  339.         bailout.caption="Bailout";
  340.         bailout.default=4.0;
  341.    
  342.  
  343.         fn1.caption="Function 1";
  344.         fn1.default = "ident" ;
  345.   
  346.  
  347.         fn2.caption="Function 2";
  348.         fn2.default = "ident" ;
  349.   
  350.  
  351.         fn3.caption="Function 3";
  352.         fn3.default = "ident" ;
  353.   
  354.  
  355.         fn4.caption="Function 4";
  356.         fn4.default = "ident" ;
  357.   
  358.     }
  359. }
  360.  
  361.  
  362. comment
  363. {
  364. ;The parametric equations of the CYCLOID are
  365. ;x=a(t-sin(t)); y=a(1-cos*t))
  366.  
  367.  
  368. }
  369.  
  370. gfpcyc01    {//Formula by Gedeon Peteri, 1999
  371.              //Based on equation of Cycloid
  372. complex c;
  373. complex Var_x;
  374. complex Var_y;
  375. parameter complex p1;
  376. parameter complex p2;
  377. parameter real bailout;
  378.  
  379.     void init(void)
  380.     {
  381.         z=fn1(pixel);
  382.     }
  383.     void loop(void)
  384.     {
  385.         c=asin(imag(z)/cabs(z));
  386.         Var_x=z*(c-sin(c));
  387.         Var_y=z*(1-cos(c));
  388.         z=fn2(z^p1) + p2*fn3(Var_x+Var_y);
  389.     }
  390.     bool bailout(void)
  391.     {
  392.         return(|z|<=bailout);
  393.     }
  394.     void description(void)
  395.     {
  396.         this.title="gfpcyc01";
  397.  
  398.         p1.caption="Exponent";
  399.         p1.default=(2.0,0.0);
  400.    
  401.  
  402.         p2.caption="Parameter";
  403.         p2.default=(1.0,0.0);
  404.    
  405.  
  406.         bailout.caption="Bailout";
  407.         bailout.default=4.0;
  408.    
  409.  
  410.         fn1.caption="Function 1";
  411.         fn1.default = "ident" ;
  412.   
  413.  
  414.         fn2.caption="Function 2";
  415.         fn2.default = "ident" ;
  416.   
  417.  
  418.         fn3.caption="Function 3";
  419.         fn3.default = "ident" ;
  420.   
  421.     }
  422. }
  423.  
  424.  
  425. gfpcyc02    {//Formula by Gedeon Peteri, 1999
  426.              //Based on equation of Cycloid
  427. complex c;
  428. complex Var_x;
  429. complex Var_y;
  430. parameter complex p1;
  431. parameter complex p2;
  432. parameter real bailout;
  433.  
  434.     void init(void)
  435.     {
  436.         z=fn1(pixel);
  437.     }
  438.     void loop(void)
  439.     {
  440.         c=asin(imag(z)/cabs(z));
  441.         Var_x=z*(c-sin(c));
  442.         Var_y=z*(1-cos(c));
  443.         z=fn2(z^p1) + p2*fn3(Var_x/Var_y);
  444.     }
  445.     bool bailout(void)
  446.     {
  447.         return(|z|<=bailout);
  448.     }
  449.     void description(void)
  450.     {
  451.         this.title="gfpcyc02";
  452.  
  453.         p1.caption="Exponent";
  454.         p1.default=(2.0,0.0);
  455.    
  456.  
  457.         p2.caption="Parameter";
  458.         p2.default=(1.0,0.0);
  459.    
  460.  
  461.         bailout.caption="Bailout";
  462.         bailout.default=4.0;
  463.    
  464.  
  465.         fn1.caption="Function 1";
  466.         fn1.default = "ident" ;
  467.   
  468.  
  469.         fn2.caption="Function 2";
  470.         fn2.default = "ident" ;
  471.   
  472.  
  473.         fn3.caption="Function 3";
  474.         fn3.default = "ident" ;
  475.   
  476.     }
  477. }
  478.  
  479.  
  480. comment
  481. {
  482. ;The general equation of a DAMPED VIBRATION CURVE is
  483. ;y=ae^-kx * sin(bx+c) where k>0.
  484.  
  485.  
  486. }
  487.  
  488. gfpdvc01    {//Formula by Gedeon Peteri, 1999
  489.              //Based on equation of Damped vibration curve
  490. complex Var_y;
  491. parameter complex p1;
  492. parameter complex p2;
  493. parameter complex p3;
  494. parameter real bailout;
  495.  
  496.     void init(void)
  497.     {
  498.         z=fn1(1/pixel);
  499.     }
  500.     void loop(void)
  501.     {
  502.         Var_y=p1*exp(p2*z)*fn2(p3*z);
  503.         z=fn3(z*z) - Var_y;
  504.     }
  505.     bool bailout(void)
  506.     {
  507.         return(|z|<=bailout);
  508.     }
  509.     void description(void)
  510.     {
  511.         this.title="gfpdvc01";
  512.  
  513.         p1.caption="Parameter 1";
  514.         p1.default=(1.0,0.0);
  515.    
  516.  
  517.         p2.caption="Parameter 2";
  518.         p2.default=(1.0,0.0);
  519.    
  520.  
  521.         p3.caption="Parameter 3";
  522.         p3.default=(1.0,0.0);
  523.    
  524.  
  525.         bailout.caption="Bailout";
  526.         bailout.default=16.0;
  527.    
  528.  
  529.         fn1.caption="Function 1";
  530.         fn1.default = "ident" ;
  531.   
  532.  
  533.         fn2.caption="Function 2";
  534.         fn2.default = "ident" ;
  535.   
  536.  
  537.         fn3.caption="Function 3";
  538.         fn3.default = "ident" ;
  539.   
  540.     }
  541. }
  542.  
  543.  
  544. gfpdvc02    {//Formula by Gedeon Peteri, 1999
  545.              //Based on equation of Damped vibration curve
  546. complex c;
  547. complex Var_y;
  548. parameter complex p1;
  549. parameter complex p2;
  550. parameter complex p3;
  551. parameter real bailout;
  552.  
  553.     void init(void)
  554.     {
  555.         z=fn1(1/pixel);
  556.         c=fn1(1/pixel);
  557.     }
  558.     void loop(void)
  559.     {
  560.         Var_y=p1*exp(c*z)*fn2(c*z + p2);
  561.         z=fn3(z^p3) - Var_y;
  562.     }
  563.     bool bailout(void)
  564.     {
  565.         return(|z|<=bailout);
  566.     }
  567.     void description(void)
  568.     {
  569.         this.title="gfpdvc02";
  570.  
  571.         p1.caption="Parameter 1";
  572.         p1.default=(1.0,0.0);
  573.    
  574.  
  575.         p2.caption="Parameter 2";
  576.         p2.default=(1.0,0.0);
  577.    
  578.  
  579.         p3.caption="Parameter 3";
  580.         p3.default=(1.0,0.0);
  581.    
  582.  
  583.         bailout.caption="Bailout";
  584.         bailout.default=16.0;
  585.    
  586.  
  587.         fn1.caption="Function 1";
  588.         fn1.default = "ident" ;
  589.   
  590.  
  591.         fn2.caption="Function 2";
  592.         fn2.default = "ident" ;
  593.   
  594.  
  595.         fn3.caption="Function 3";
  596.         fn3.default = "ident" ;
  597.   
  598.     }
  599. }
  600.  
  601.  
  602. comment
  603. {
  604. ;The parametric equations of the FOLIUM OF DESCARTES are
  605. ;x=3at/(1+t^3), y=3at^2/(1+t^3); let p1=3a
  606.  
  607.  
  608. }
  609.  
  610. gfpfod01    {//Formula by Gedeon Peteri, 1999
  611.              //Based on equation of Folium of Descartes
  612. complex Var_x;
  613. parameter complex p1;
  614. complex Var_y;
  615. parameter complex p3;
  616. parameter complex p2;
  617. parameter real bailout;
  618.  
  619.     void init(void)
  620.     {
  621.         z=fn1(pixel);
  622.     }
  623.     void loop(void)
  624.     {
  625.         Var_x=p1*z/(1+z*z*z);
  626.         Var_y=p1*z*z/(1+z*z*z);
  627.         z=fn1(z^p3) + p2*(fn2(Var_x) + fn3(Var_y));
  628.     }
  629.     bool bailout(void)
  630.     {
  631.         return(|z|<=bailout);
  632.     }
  633.     void description(void)
  634.     {
  635.         this.title="gfpfod01";
  636.  
  637.         p1.caption="Parameter 1";
  638.         p1.default=(1.0,0.0);
  639.    
  640.  
  641.         p2.caption="Parameter 2";
  642.         p2.default=(1.0,0.0);
  643.    
  644.  
  645.         p3.caption="Exponent";
  646.         p3.default=(2.0,0.0);
  647.    
  648.  
  649.         bailout.caption="Bailout";
  650.         bailout.default=4.0;
  651.    
  652.  
  653.         fn1.caption="Function 1";
  654.         fn1.default = "recip" ;
  655.   
  656.  
  657.         fn2.caption="Function 2";
  658.         fn2.default = "ident" ;
  659.   
  660.  
  661.         fn3.caption="Function 3";
  662.         fn3.default = "ident" ;
  663.   
  664.     }
  665. }
  666.  
  667.  
  668. gfpfod02    {//Formula by Gedeon Peteri, 1999
  669.              //Based on equation of Folium of Descartes
  670. complex c;
  671. complex Var_x;
  672. parameter complex p1;
  673. complex Var_y;
  674. parameter complex p3;
  675. parameter complex p2;
  676. parameter real bailout;
  677.  
  678.     void init(void)
  679.     {
  680.         z=fn1(pixel);
  681.     }
  682.     void loop(void)
  683.     {
  684.         c=asin(imag(z)/cabs(z));
  685.         Var_x=p1*z/(1+z*z*z);
  686.         Var_y=p1*z*z/(1+z*z*z);
  687.         z=fn1(z^p3) + p2*(fn2(Var_x*c) + fn3(Var_y*c));
  688.     }
  689.     bool bailout(void)
  690.     {
  691.         return(|z|<=bailout);
  692.     }
  693.     void description(void)
  694.     {
  695.         this.title="gfpfod02";
  696.  
  697.         p1.caption="Parameter 1";
  698.         p1.default=(1.0,0.0);
  699.    
  700.  
  701.         p2.caption="Parameter 2";
  702.         p2.default=(1.0,0.0);
  703.    
  704.  
  705.         p3.caption="Exponent";
  706.         p3.default=(2.0,0.0);
  707.    
  708.  
  709.         bailout.caption="Bailout";
  710.         bailout.default=4.0;
  711.    
  712.  
  713.         fn1.caption="Function 1";
  714.         fn1.default = "recip" ;
  715.   
  716.  
  717.         fn2.caption="Function 2";
  718.         fn2.default = "ident" ;
  719.   
  720.  
  721.         fn3.caption="Function 3";
  722.         fn3.default = "ident" ;
  723.   
  724.     }
  725. }
  726.  
  727.  
  728. comment
  729. {
  730. ;HYPERBOLIC SPIRAL r*t=a [or r=a/t] and its first derivative r'=-a/(t^2)
  731.  
  732.  
  733. }
  734.  
  735. gfphsp01    {//Formula by Gedeon Peteri, 1999
  736.              //Based on equation of Hyperbolic spiral
  737. parameter complex p1;
  738. parameter complex p2;
  739. parameter complex p3;
  740. parameter real bailout;
  741.  
  742.     void init(void)
  743.     {
  744.         z=fn1(pixel);
  745.     }
  746.     void loop(void)
  747.     {
  748.         z=fn2(z^p1) + p2*fn3(-p3/(z*z));
  749.     }
  750.     bool bailout(void)
  751.     {
  752.         return(|z|<=bailout);
  753.     }
  754.     void description(void)
  755.     {
  756.         this.title="gfphsp01";
  757.  
  758.         p1.caption="Exponent";
  759.         p1.default=(2.0,0.0);
  760.    
  761.  
  762.         p2.caption="Parameter 1";
  763.         p2.default=(1.0,0.0);
  764.    
  765.  
  766.         p3.caption="Parameter 2";
  767.         p3.default=(1.0,0.0);
  768.    
  769.  
  770.         bailout.caption="Bailout";
  771.         bailout.default=4.0;
  772.    
  773.  
  774.         fn1.caption="Function 1";
  775.         fn1.default = "ident" ;
  776.   
  777.  
  778.         fn2.caption="Function 2";
  779.         fn2.default = "ident" ;
  780.   
  781.  
  782.         fn3.caption="Function 3";
  783.         fn3.default = "ident" ;
  784.   
  785.     }
  786. }
  787.  
  788.  
  789. comment
  790. {
  791. ;The parametric equations of the HYPOCYCLOID are
  792. ;x=(a-b)cos(t)+b*cos((a-b)/b*t)
  793. ;y=(a-b)sin(t)-b*sin((a-b)/b*t)
  794.  
  795.  
  796. }
  797.  
  798. gfphyc01    {//Formula by Gedeon Peteri, 1999
  799.              //Based on equations of the Hypocycloid
  800. complex a;
  801. parameter complex p2;
  802. complex b;
  803. complex c;
  804. complex Var_x;
  805. complex Var_y;
  806. parameter complex p1;
  807. parameter complex p3;
  808. parameter real bailout;
  809.  
  810.     void init(void)
  811.     {
  812.         z=fn1(pixel);
  813.         a=real(p2);
  814.         b=imag(p2);
  815.     }
  816.     void loop(void)
  817.     {
  818.         c=asin(imag(z)/cabs(z));
  819.         Var_x=(a-b)*cos(c)+b*cos(((a-b)/b)*c);
  820.         Var_y=(a-b)*sin(c)-b*sin(((a-b)/b)*c);
  821.         z=fn2(z^p1) + p3*fn3(Var_x+Var_y);
  822.     }
  823.     bool bailout(void)
  824.     {
  825.         return(|z|<=bailout);
  826.     }
  827.     void description(void)
  828.     {
  829.         this.title="gfphyc01";
  830.  
  831.         p1.caption="Exponent";
  832.         p1.default=(2.0,0.0);
  833.    
  834.  
  835.         p2.caption="Parameter 1";
  836.         p2.default=(1.0,0.5);
  837.    
  838.  
  839.         p3.caption="Parameter 2";
  840.         p3.default=(1.0,0.0);
  841.    
  842.  
  843.         bailout.caption="Bailout";
  844.         bailout.default=4.0;
  845.    
  846.  
  847.         fn1.caption="Function 1";
  848.         fn1.default = "ident" ;
  849.   
  850.  
  851.         fn2.caption="Function 2";
  852.         fn2.default = "ident" ;
  853.   
  854.  
  855.         fn3.caption="Function 3";
  856.         fn3.default = "ident" ;
  857.   
  858.     }
  859. }
  860.  
  861.  
  862. comment
  863. {
  864. ;The parametric equations of the Involute of a circle are
  865. ;x=a*cos(t)+at*sin(t); y=a*sin(t)-at*cos(t)
  866.  
  867.  
  868. }
  869.  
  870. gfpinc01    {//Formula by Gedeon Peteri, 1999
  871.              //Based on equations of the Involute of a circle
  872. complex c;
  873. complex Var_x;
  874. parameter complex p2;
  875. complex Var_y;
  876. parameter complex p1;
  877. parameter complex p3;
  878. parameter real bailout;
  879.  
  880.     void init(void)
  881.     {
  882.         z=fn1(pixel);
  883.     }
  884.     void loop(void)
  885.     {
  886.         c=asin(imag(z)/cabs(z));
  887.         Var_x=p2*cos(c)+p2*c*sin(c);
  888.         Var_y=p2*sin(c)-p2*c*cos(c);
  889.         z=fn2(z^p1) + p3*fn3(Var_x+Var_y);
  890.     }
  891.     bool bailout(void)
  892.     {
  893.         return(|z|<=bailout);
  894.     }
  895.     void description(void)
  896.     {
  897.         this.title="gfpinc01";
  898.  
  899.         p1.caption="Exponent";
  900.         p1.default=(2.0,0.0);
  901.    
  902.  
  903.         p2.caption="Parameter 1";
  904.         p2.default=(1.0,0.0);
  905.    
  906.  
  907.         p3.caption="Parameter 2";
  908.         p3.default=(1.0,0.0);
  909.    
  910.  
  911.         bailout.caption="Bailout";
  912.         bailout.default=4.0;
  913.    
  914.  
  915.         fn1.caption="Function 1";
  916.         fn1.default = "ident" ;
  917.   
  918.  
  919.         fn2.caption="Function 2";
  920.         fn2.default = "ident" ;
  921.   
  922.  
  923.         fn3.caption="Function 3";
  924.         fn3.default = "ident" ;
  925.   
  926.     }
  927. }
  928.  
  929.  
  930. comment
  931. {
  932. ;The equation for the LEMNISCATE OF BERNOULLI is
  933. ;(x^2+y^2)^2 = 2a^2(x^2-y^2), or 2a^2(x^2-y^2)-(x^2+y^2)^2 = 0
  934.  
  935.  
  936. }
  937.  
  938. gfplob01    {//Formula by Gedeon Peteri, 1999
  939.              //Based on equation of Lemniscate of Bernoulli
  940. complex Var_x;
  941. complex Var_y;
  942. parameter complex p1;
  943. parameter complex p2;
  944. parameter real bailout;
  945.  
  946.     void init(void)
  947.     {
  948.         z=fn1(pixel);
  949.         Var_x=real(z);
  950.         Var_y=imag(z);
  951.     }
  952.     void loop(void)
  953.     {
  954.         z=fn2(z^p1)+p2*fn3(Var_x*Var_x-Var_y*Var_y-sqr(Var_x*Var_x+Var_y*Var_y));
  955.     }
  956.     bool bailout(void)
  957.     {
  958.         return(|z|<=bailout);
  959.     }
  960.     void description(void)
  961.     {
  962.         this.title="gfplob01";
  963.  
  964.         p1.caption="Exponent";
  965.         p1.default=(2.0,0.0);
  966.    
  967.  
  968.         p2.caption="Parameter";
  969.         p2.default=(1.0,0.0);
  970.    
  971.  
  972.         bailout.caption="Bailout";
  973.         bailout.default=4.0;
  974.    
  975.  
  976.         fn1.caption="Function 1";
  977.         fn1.default = "ident" ;
  978.   
  979.  
  980.         fn2.caption="Function 2";
  981.         fn2.default = "ident" ;
  982.   
  983.  
  984.         fn3.caption="Function 3";
  985.         fn3.default = "ident" ;
  986.   
  987.     }
  988. }
  989.  
  990.  
  991. gfplob02    {//Formula by Gedeon Peteri, 1999
  992.              //Based on equation of Lemniscate of Bernoulli
  993. complex Var_x;
  994. complex Var_y;
  995. complex c;
  996. parameter complex p1;
  997. parameter complex p2;
  998. parameter real bailout;
  999.  
  1000.     void init(void)
  1001.     {
  1002.         z=fn1(pixel);
  1003.         Var_x=real(z);
  1004.         Var_y=imag(z);
  1005.     }
  1006.     void loop(void)
  1007.     {
  1008.         c=asin(imag(z)/cabs(z));
  1009.         z=fn2(z^p1)+p2*(fn3(c)*fn4(Var_x*Var_x-Var_y*Var_y-sqr(Var_x*Var_x+Var_y*Var_y)));
  1010.     }
  1011.     bool bailout(void)
  1012.     {
  1013.         return(|z|<=bailout);
  1014.     }
  1015.     void description(void)
  1016.     {
  1017.         this.title="gfplob02";
  1018.  
  1019.         p1.caption="Exponent";
  1020.         p1.default=(2.0,0.0);
  1021.    
  1022.  
  1023.         p2.caption="Parameter";
  1024.         p2.default=(1.0,0.0);
  1025.    
  1026.  
  1027.         bailout.caption="Bailout";
  1028.         bailout.default=4.0;
  1029.    
  1030.  
  1031.         fn1.caption="Function 1";
  1032.         fn1.default = "ident" ;
  1033.   
  1034.  
  1035.         fn2.caption="Function 2";
  1036.         fn2.default = "ident" ;
  1037.   
  1038.  
  1039.         fn3.caption="Function 3";
  1040.         fn3.default = "ident" ;
  1041.   
  1042.  
  1043.         fn4.caption="Function 4";
  1044.         fn4.default = "ident" ;
  1045.   
  1046.     }
  1047. }
  1048.  
  1049.  
  1050. gfplob03    {//Formula by Gedeon Peteri, 1999
  1051.              //Based on equation of Lemniscate of Bernoulli
  1052. complex Var_x;
  1053. complex Var_y;
  1054. complex c;
  1055. parameter complex p1;
  1056. parameter complex p2;
  1057. parameter real bailout;
  1058.  
  1059.     void init(void)
  1060.     {
  1061.         z=fn1(pixel);
  1062.         Var_x=real(z);
  1063.         Var_y=imag(z);
  1064.     }
  1065.     void loop(void)
  1066.     {
  1067.         c=asin(imag(z)/cabs(z));
  1068.         z=fn2(z^p1)+p2*(fn3(cos(c))*fn4(Var_x*Var_x-Var_y*Var_y-sqr(Var_x*Var_x+Var_y*Var_y)));
  1069.     }
  1070.     bool bailout(void)
  1071.     {
  1072.         return(|z|<=bailout);
  1073.     }
  1074.     void description(void)
  1075.     {
  1076.         this.title="gfplob03";
  1077.  
  1078.         p1.caption="Exponent";
  1079.         p1.default=(2.0,0.0);
  1080.    
  1081.  
  1082.         p2.caption="Parameter";
  1083.         p2.default=(1.0,0.0);
  1084.    
  1085.  
  1086.         bailout.caption="Bailout";
  1087.         bailout.default=4.0;
  1088.    
  1089.  
  1090.         fn1.caption="Function 1";
  1091.         fn1.default = "ident" ;
  1092.   
  1093.  
  1094.         fn2.caption="Function 2";
  1095.         fn2.default = "ident" ;
  1096.   
  1097.  
  1098.         fn3.caption="Function 3";
  1099.         fn3.default = "ident" ;
  1100.   
  1101.  
  1102.         fn4.caption="Function 4";
  1103.         fn4.default = "ident" ;
  1104.   
  1105.     }
  1106. }
  1107.  
  1108.  
  1109. comment
  1110. {
  1111. ;The polar equation of the LIMACON OF PASCAL is
  1112. ;r=2a*cos(t)+b
  1113.  
  1114.  
  1115. }
  1116.  
  1117. gfplop01    {//Formula by Gedeon Peteri, 1999
  1118.              //Based on equation of Limacon of Pascal
  1119. parameter complex p1;
  1120. parameter complex p2;
  1121. parameter complex p3;
  1122. parameter real bailout;
  1123.  
  1124.     void init(void)
  1125.     {
  1126.         z=fn1(pixel);
  1127.     }
  1128.     void loop(void)
  1129.     {
  1130.         z=fn2(z^p1) + fn3(2*p2*cos(z)+p3);
  1131.     }
  1132.     bool bailout(void)
  1133.     {
  1134.         return(|z|<=bailout);
  1135.     }
  1136.     void description(void)
  1137.     {
  1138.         this.title="gfplop01";
  1139.  
  1140.         p1.caption="Exponent";
  1141.         p1.default=(1.0,0.0);
  1142.    
  1143.  
  1144.         p2.caption="Parameter 1";
  1145.         p2.default=(1.0,0.0);
  1146.    
  1147.  
  1148.         p3.caption="Parameter 2";
  1149.         p3.default=(2.0,0.0);
  1150.    
  1151.  
  1152.         bailout.caption="Bailout";
  1153.         bailout.default=4.0;
  1154.    
  1155.  
  1156.         fn1.caption="Function 1";
  1157.         fn1.default = "ident" ;
  1158.   
  1159.  
  1160.         fn2.caption="Function 2";
  1161.         fn2.default = "ident" ;
  1162.   
  1163.  
  1164.         fn3.caption="Function 3";
  1165.         fn3.default = "ident" ;
  1166.   
  1167.     }
  1168. }
  1169.  
  1170.  
  1171. comment
  1172. {
  1173. ;LOGARITHMIC SPIRAL r=e^(a*t) and first derivative r'=e^(a*t) * log e * a
  1174.  
  1175.  
  1176. }
  1177.  
  1178. gfplsp01    {//Formula by Gedeon Peteri, 1999
  1179.              //Based on equation of Logarithmic spiral
  1180. parameter complex p1;
  1181. parameter complex p2;
  1182. parameter complex p3;
  1183. parameter real bailout;
  1184.  
  1185.     void init(void)
  1186.     {
  1187.         z=fn1(pixel);
  1188.     }
  1189.     void loop(void)
  1190.     {
  1191.         z=fn2(z^p1) + p2*fn3(exp(p3*z));
  1192.     }
  1193.     bool bailout(void)
  1194.     {
  1195.         return(|z|<=bailout);
  1196.     }
  1197.     void description(void)
  1198.     {
  1199.         this.title="gfplsp01";
  1200.  
  1201.         p1.caption="Exponent";
  1202.         p1.default=(2.0,0.0);
  1203.    
  1204.  
  1205.         p2.caption="Parameter 1";
  1206.         p2.default=(1.0,0.0);
  1207.    
  1208.  
  1209.         p3.caption="Parameter 2";
  1210.         p3.default=(1.0,0.0);
  1211.    
  1212.  
  1213.         bailout.caption="Bailout";
  1214.         bailout.default=4.0;
  1215.    
  1216.  
  1217.         fn1.caption="Function 1";
  1218.         fn1.default = "ident" ;
  1219.   
  1220.  
  1221.         fn2.caption="Function 2";
  1222.         fn2.default = "ident" ;
  1223.   
  1224.  
  1225.         fn3.caption="Function 3";
  1226.         fn3.default = "ident" ;
  1227.   
  1228.     }
  1229. }
  1230.  
  1231.  
  1232. gfplsp02    {//Formula by Gedeon Peteri, 1999
  1233.              //Based on equation of Logarithmic spiral
  1234. parameter complex p1;
  1235. parameter complex p2;
  1236. parameter complex p3;
  1237. parameter real bailout;
  1238.  
  1239.     void init(void)
  1240.     {
  1241.         z=fn1(pixel);
  1242.     }
  1243.     void loop(void)
  1244.     {
  1245.         z=fn2(z^p1) + p2*fn3(exp(p3*z)*log(e*p3));
  1246.     }
  1247.     bool bailout(void)
  1248.     {
  1249.         return(|z|<=bailout);
  1250.     }
  1251.     void description(void)
  1252.     {
  1253.         this.title="gfplsp02";
  1254.  
  1255.         p1.caption="Exponent";
  1256.         p1.default=(2.0,0.0);
  1257.    
  1258.  
  1259.         p2.caption="Parameter 1";
  1260.         p2.default=(1.0,0.0);
  1261.    
  1262.  
  1263.         p3.caption="Parameter 2";
  1264.         p3.default=(1.0,0.0);
  1265.    
  1266.  
  1267.         bailout.caption="Bailout";
  1268.         bailout.default=4.0;
  1269.    
  1270.  
  1271.         fn1.caption="Function 1";
  1272.         fn1.default = "ident" ;
  1273.   
  1274.  
  1275.         fn2.caption="Function 2";
  1276.         fn2.default = "ident" ;
  1277.   
  1278.  
  1279.         fn3.caption="Function 3";
  1280.         fn3.default = "ident" ;
  1281.   
  1282.     }
  1283. }
  1284.  
  1285.  
  1286. comment
  1287. {
  1288. ;The equation of the PROBABILITY CURVE is
  1289. ;y=e^(-x^2/2)/(2*pi)^(1/2)
  1290.  
  1291.  
  1292. }
  1293.  
  1294. gfppro01    {//Formula by Gedeon Peteri, 1999
  1295.              //Based on equation of Probability curve
  1296. parameter complex p1;
  1297. parameter complex p2;
  1298. parameter real bailout;
  1299.  
  1300.     void init(void)
  1301.     {
  1302.         z=fn1(pixel);
  1303.     }
  1304.     void loop(void)
  1305.     {
  1306.         z=fn2(z^p1)-p2*fn3(exp(-z*z/2)/sqrt(6.28318530718));
  1307.     }
  1308.     bool bailout(void)
  1309.     {
  1310.         return(|z|<=bailout);
  1311.     }
  1312.     void description(void)
  1313.     {
  1314.         this.title="gfppro01";
  1315.  
  1316.         p1.caption="Exponent";
  1317.         p1.default=(2.0,0.0);
  1318.    
  1319.  
  1320.         p2.caption="Parameter";
  1321.         p2.default=(1.0,0.0);
  1322.    
  1323.  
  1324.         bailout.caption="Bailout";
  1325.         bailout.default=4.0;
  1326.    
  1327.  
  1328.         fn1.caption="Function 1";
  1329.         fn1.default = "ident" ;
  1330.   
  1331.  
  1332.         fn2.caption="Function 2";
  1333.         fn2.default = "ident" ;
  1334.   
  1335.  
  1336.         fn3.caption="Function 3";
  1337.         fn3.default = "ident" ;
  1338.   
  1339.     }
  1340. }
  1341.  
  1342.  
  1343. comment
  1344. {
  1345. ;The polar equations of the ROSE-LEAVED CURVES are
  1346. ;r=a*sin(nt); and r=a*cos(nt)); if n is even curve has 2n loops
  1347.  
  1348.  
  1349. }
  1350.  
  1351. gfpros01    {//Formula by Gedeon Peteri, 1999
  1352.              //Based on equation of Rose-leaved curve
  1353. complex c;
  1354. parameter complex p1;
  1355. parameter complex p2;
  1356. parameter complex p3;
  1357. parameter real bailout;
  1358.  
  1359.     void init(void)
  1360.     {
  1361.         z=fn1(pixel);
  1362.     }
  1363.     void loop(void)
  1364.     {
  1365.         c=asin(imag(z)/cabs(z));
  1366.         z=fn2(z^p1) + p2*fn3(sin(p3*c));
  1367.     }
  1368.     bool bailout(void)
  1369.     {
  1370.         return(|z|<=bailout);
  1371.     }
  1372.     void description(void)
  1373.     {
  1374.         this.title="gfpros01";
  1375.  
  1376.         p1.caption="Exponent";
  1377.         p1.default=(2.0,0.0);
  1378.    
  1379.  
  1380.         p2.caption="Parameter 1";
  1381.         p2.default=(1.0,0.0);
  1382.    
  1383.  
  1384.         p2.caption="Parameter 2";
  1385.         p2.default=(1.0,0.0);
  1386.    
  1387.  
  1388.         bailout.caption="Bailout";
  1389.         bailout.default=4.0;
  1390.    
  1391.  
  1392.         fn1.caption="Function 1";
  1393.         fn1.default = "ident" ;
  1394.   
  1395.  
  1396.         fn2.caption="Function 2";
  1397.         fn2.default = "ident" ;
  1398.   
  1399.  
  1400.         fn3.caption="Function 3";
  1401.         fn3.default = "ident" ;
  1402.   
  1403.     }
  1404. }
  1405.  
  1406.  
  1407. comment
  1408. {
  1409. ;Some simple algebraic curves
  1410.  
  1411.  
  1412. }
  1413.  
  1414. gfpsac01    {//Formula by Gedeon Peteri, 1999
  1415.              //Based on equation y^2=(x-1)(x-2)(x-3)
  1416. complex a;
  1417. parameter complex p1;
  1418. parameter complex p2;
  1419. parameter real bailout;
  1420.  
  1421.     void init(void)
  1422.     {
  1423.         z=fn1(pixel);
  1424.         a=p1;
  1425.     }
  1426.     void loop(void)
  1427.     {
  1428.         z=fn2(z^a) + p2*fn3(sqrt((z-1)*(z-2)*(z-3)));
  1429.     }
  1430.     bool bailout(void)
  1431.     {
  1432.         return(|z|<=bailout);
  1433.     }
  1434.     void description(void)
  1435.     {
  1436.         this.title="gfpsac01";
  1437.  
  1438.         p1.caption="Exponent";
  1439.         p1.default=(2.0,0.0);
  1440.    
  1441.  
  1442.         p2.caption="Parameter";
  1443.         p2.default=(1.0,0.0);
  1444.    
  1445.  
  1446.         bailout.caption="Bailout";
  1447.         bailout.default=4.0;
  1448.    
  1449.  
  1450.         fn1.caption="Function 1";
  1451.         fn1.default = "ident" ;
  1452.   
  1453.  
  1454.         fn2.caption="Function 2";
  1455.         fn2.default = "ident" ;
  1456.   
  1457.  
  1458.         fn3.caption="Function 3";
  1459.         fn3.default = "ident" ;
  1460.   
  1461.     }
  1462. }
  1463.  
  1464.  
  1465. comment
  1466. {
  1467. ;The parametric equations of the STROPHOID are
  1468. ;x=+/-a*sinw, y=a*tanw*(1 +/- sinw)
  1469.  
  1470.  
  1471. }
  1472.  
  1473. gfpstr01    {//Formula by Gedeon Peteri, 1999
  1474.              //Based on equation of Strophoid
  1475. complex Var_x;
  1476. parameter complex p1;
  1477. complex Var_y;
  1478. parameter complex p3;
  1479. parameter complex p2;
  1480. parameter real bailout;
  1481.  
  1482.     void init(void)
  1483.     {
  1484.         z=fn1(pixel);
  1485.     }
  1486.     void loop(void)
  1487.     {
  1488.         Var_x=p1*sin(z);
  1489.         Var_y=p1*(tan(z)*(1-sin(z)));
  1490.         z=fn2(z^p3) + p2*((fn3(Var_x) + fn4(Var_y)));
  1491.     }
  1492.     bool bailout(void)
  1493.     {
  1494.         return(|z|<=bailout);
  1495.     }
  1496.     void description(void)
  1497.     {
  1498.         this.title="gfpstr01";
  1499.  
  1500.         p1.caption="Parameter 1";
  1501.         p1.default=(1.0,0.0);
  1502.    
  1503.  
  1504.         p2.caption="Parameter 2";
  1505.         p2.default=(-1.0,0.0);
  1506.    
  1507.  
  1508.         p3.caption="Exponent";
  1509.         p3.default=(2.0,0.0);
  1510.    
  1511.  
  1512.         bailout.caption="Bailout";
  1513.         bailout.default=4.0;
  1514.    
  1515.  
  1516.         fn1.caption="Function 1";
  1517.         fn1.default = "ident" ;
  1518.   
  1519.  
  1520.         fn2.caption="Function 2";
  1521.         fn2.default = "ident" ;
  1522.   
  1523.  
  1524.         fn3.caption="Function 3";
  1525.         fn3.default = "ident" ;
  1526.   
  1527.  
  1528.         fn4.caption="Function 4";
  1529.         fn4.default = "ident" ;
  1530.   
  1531.     }
  1532. }
  1533.  
  1534.  
  1535. comment
  1536. {
  1537. ;Parametric equations of the WITCH OF AGNESI are
  1538. ;x=a*cot alpha, y=a*sin^2 alpha
  1539.  
  1540.  
  1541. }
  1542.  
  1543. gfpwoa01    {//Formula by Gedeon Peteri, 1999
  1544.              //Based on equation of Witch of Agnesi
  1545. complex Var_x;
  1546. parameter complex p1;
  1547. complex Var_y;
  1548. parameter complex p3;
  1549. parameter complex p2;
  1550. parameter real bailout;
  1551.  
  1552.     void init(void)
  1553.     {
  1554.         z=fn1(pixel);
  1555.     }
  1556.     void loop(void)
  1557.     {
  1558.         Var_x=p1*cotan(z);
  1559.         Var_y=p1*sin(z)*sin(z);
  1560.         z=fn2(z^p3) + p2*(fn3(Var_x)+fn4(Var_y));
  1561.     }
  1562.     bool bailout(void)
  1563.     {
  1564.         return(|z|<=bailout);
  1565.     }
  1566.     void description(void)
  1567.     {
  1568.         this.title="gfpwoa01";
  1569.  
  1570.         p1.caption="Parameter 1";
  1571.         p1.default=(1.0,0.0);
  1572.    
  1573.  
  1574.         p2.caption="Parameter 2";
  1575.         p2.default=(1.0,0.0);
  1576.    
  1577.  
  1578.         p3.caption="Exponent";
  1579.         p3.default=(2.0,0.0);
  1580.    
  1581.  
  1582.         bailout.caption="Bailout";
  1583.         bailout.default=4.0;
  1584.    
  1585.  
  1586.         fn1.caption="Function 1";
  1587.         fn1.default = "ident" ;
  1588.   
  1589.  
  1590.         fn2.caption="Function 2";
  1591.         fn2.default = "ident" ;
  1592.   
  1593.  
  1594.         fn3.caption="Function 3";
  1595.         fn3.default = "ident" ;
  1596.   
  1597.  
  1598.         fn4.caption="Function 4";
  1599.         fn4.default = "ident" ;
  1600.   
  1601.     }
  1602. }
  1603.  
  1604.  
  1605. gfpwoa02    {//Formula by Gedeon Peteri, 1999
  1606.              //Based on equation of Witch of Agnesi
  1607. complex Var_x;
  1608. parameter complex p1;
  1609. complex Var_y;
  1610. parameter complex p3;
  1611. parameter complex p2;
  1612. parameter real bailout;
  1613.  
  1614.     void init(void)
  1615.     {
  1616.         z=fn1(pixel);
  1617.     }
  1618.     void loop(void)
  1619.     {
  1620.         Var_x=p1*cotan(z);
  1621.         Var_y=p1*sin(z)*sin(z);
  1622.         z=fn2(z^p3) + p2*(fn3(Var_x)*fn4(Var_y));
  1623.     }
  1624.     bool bailout(void)
  1625.     {
  1626.         return(|z|<=bailout);
  1627.     }
  1628.     void description(void)
  1629.     {
  1630.         this.title="gfpwoa02";
  1631.  
  1632.         p1.caption="Parameter 1";
  1633.         p1.default=(1.0,0.0);
  1634.    
  1635.  
  1636.         p2.caption="Parameter 2";
  1637.         p2.default=(1.0,0.0);
  1638.    
  1639.  
  1640.         p3.caption="Exponent";
  1641.         p3.default=(2.0,0.0);
  1642.    
  1643.  
  1644.         bailout.caption="Bailout";
  1645.         bailout.default=4.0;
  1646.    
  1647.  
  1648.         fn1.caption="Function 1";
  1649.         fn1.default = "ident" ;
  1650.   
  1651.  
  1652.         fn2.caption="Function 2";
  1653.         fn2.default = "ident" ;
  1654.   
  1655.  
  1656.         fn3.caption="Function 3";
  1657.         fn3.default = "ident" ;
  1658.   
  1659.  
  1660.         fn4.caption="Function 4";
  1661.         fn4.default = "ident" ;
  1662.   
  1663.     }
  1664. }
  1665.  
  1666.  
  1667. comment
  1668. {
  1669. ;The following formulas are identical to the
  1670. ;preceding ones in every respect except that
  1671. ;a bailout test parameter has been added.
  1672. ;I regret that adding such a parameter occurred
  1673. ;to me long after many par files have been
  1674. ;published by myself and others based on the
  1675. ;formulas not having it, making this otherwise
  1676. ;unnecessary duplication advisable.
  1677.  
  1678. ;The equation of the CATENARY is
  1679. ;y=a/2*(e^(x/a) + e^-(x/a))
  1680.  
  1681.  
  1682. }
  1683.  
  1684. gfp2cat01   {//Formula by Gedeon Peteri, 1999
  1685.              //Based on equation of Catenary
  1686. parameter complex p1;
  1687. parameter complex p3;
  1688. parameter complex p2;
  1689. parameter int test;
  1690. parameter real bailout;
  1691.  
  1692.     void init(void)
  1693.     {
  1694.         z=fn1(pixel);
  1695.     }
  1696.     void loop(void)
  1697.     {
  1698.         z=fn2(z^p1) - p3*(fn3(p2/2*(exp(z/p2)+1/exp(z/p2))));
  1699.     }
  1700.     bool bailout(void)
  1701.     {
  1702.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  1703.     }
  1704.     void description(void)
  1705.     {
  1706.         this.title="gfp2cat01";
  1707.  
  1708.         p1.caption="Exponent";
  1709.         p1.default=(2.0,0.0);
  1710.    
  1711.  
  1712.         p2.caption="Parameter 1";
  1713.         p2.default=(2.0,0.0);
  1714.    
  1715.  
  1716.         p3.caption="Parameter 2";
  1717.         p3.default=(1.0,0.0);
  1718.    
  1719.  
  1720.         bailout.caption="Bailout";
  1721.         bailout.default=4.0;
  1722.    
  1723.  
  1724.         test.caption = "Bailout Test";
  1725.         test.default = 0;
  1726.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  1727.    
  1728.  
  1729.         fn1.caption="Function 1";
  1730.         fn1.default = "ident" ;
  1731.   
  1732.  
  1733.         fn2.caption="Function 2";
  1734.         fn2.default = "ident" ;
  1735.   
  1736.  
  1737.         fn3.caption="Function 3";
  1738.         fn3.default = "ident" ;
  1739.   
  1740.     }
  1741. }
  1742.  
  1743.  
  1744. comment
  1745. {
  1746. ;The parametric equations of the CAUSTIC are
  1747. ;x=3/4 cos(t) - 1/4 cos(3t); y=3/4 sin(t) - 1/4 sin(3t)
  1748.  
  1749.  
  1750. }
  1751.  
  1752. gfp2cau01   {//Formula by Gedeon Peteri, 1999
  1753.              //Based on equation of Caustic
  1754. complex c;
  1755. complex Var_x;
  1756. complex Var_y;
  1757. parameter complex p1;
  1758. parameter complex p2;
  1759. parameter int test;
  1760. parameter real bailout;
  1761.  
  1762.     void init(void)
  1763.     {
  1764.         z=fn1(pixel);
  1765.     }
  1766.     void loop(void)
  1767.     {
  1768.         c=asin(imag(z)/cabs(z));
  1769.         Var_x=.75*cos(c)-.25*cos(3*c);
  1770.         Var_y=.75*sin(c)-.25*sin(3*c);
  1771.         z=fn2(z^p1)+p2*fn3(Var_x-flip(Var_y));
  1772.     }
  1773.     bool bailout(void)
  1774.     {
  1775.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  1776.     }
  1777.     void description(void)
  1778.     {
  1779.         this.title="gfp2cau01";
  1780.  
  1781.         p1.caption="Exponent";
  1782.         p1.default=(2.0,0.0);
  1783.    
  1784.  
  1785.         p2.caption="Parameter";
  1786.         p2.default=(1.0,0.0);
  1787.    
  1788.  
  1789.         bailout.caption="Bailout";
  1790.         bailout.default=4.0;
  1791.    
  1792.  
  1793.         test.caption = "Bailout Test";
  1794.         test.default = 0;
  1795.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  1796.    
  1797.  
  1798.         fn1.caption="Function 1";
  1799.         fn1.default = "ident" ;
  1800.   
  1801.  
  1802.         fn2.caption="Function 2";
  1803.         fn2.default = "ident" ;
  1804.   
  1805.  
  1806.         fn3.caption="Function 3";
  1807.         fn3.default = "ident" ;
  1808.   
  1809.     }
  1810. }
  1811.  
  1812.  
  1813. gfp2cau02   {//Formula by Gedeon Peteri, 1999
  1814.              //Based on equation of Caustic
  1815. complex c;
  1816. complex Var_x;
  1817. complex Var_y;
  1818. parameter complex p1;
  1819. parameter complex p2;
  1820. parameter int test;
  1821. parameter real bailout;
  1822.  
  1823.     void init(void)
  1824.     {
  1825.         z=fn1(pixel);
  1826.     }
  1827.     void loop(void)
  1828.     {
  1829.         c=asin(imag(z)/cabs(z));
  1830.         Var_x=.75*cos(c)-.25*cos(3*c);
  1831.         Var_y=.75*sin(c)-.25*sin(3*c);
  1832.         z=fn2(z^p1)+p2*fn3(Var_y-flip(Var_x));
  1833.     }
  1834.     bool bailout(void)
  1835.     {
  1836.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  1837.     }
  1838.     void description(void)
  1839.     {
  1840.         this.title="gfp2cau02";
  1841.  
  1842.         p1.caption="Exponent";
  1843.         p1.default=(2.0,0.0);
  1844.    
  1845.  
  1846.         p2.caption="Parameter";
  1847.         p2.default=(1.0,0.0);
  1848.    
  1849.  
  1850.         bailout.caption="Bailout";
  1851.         bailout.default=4.0;
  1852.    
  1853.  
  1854.         test.caption = "Bailout Test";
  1855.         test.default = 0;
  1856.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  1857.    
  1858.  
  1859.         fn1.caption="Function 1";
  1860.         fn1.default = "ident" ;
  1861.   
  1862.  
  1863.         fn2.caption="Function 2";
  1864.         fn2.default = "ident" ;
  1865.   
  1866.  
  1867.         fn3.caption="Function 3";
  1868.         fn3.default = "ident" ;
  1869.   
  1870.     }
  1871. }
  1872.  
  1873.  
  1874. comment
  1875. {
  1876. ;The equation of the CISSOID OF DIOCLES is
  1877. ;y^2=x^3/(2a-x), or y=+/- (x^3/(2a-x))^.5
  1878.  
  1879.  
  1880. }
  1881.  
  1882. gfp2cod01   {//Formula by Gedeon Peteri, 1999
  1883.              //Based on equation of Cissoid of Diocles
  1884. complex Var_x;
  1885. parameter complex p1;
  1886. complex Var_y;
  1887. parameter complex p3;
  1888. parameter complex p2;
  1889. parameter int test;
  1890. parameter real bailout;
  1891.  
  1892.     void init(void)
  1893.     {
  1894.         z=fn1(pixel);
  1895.     }
  1896.     void loop(void)
  1897.     {
  1898.         Var_x=sqrt(z^3/(p1-z));
  1899.         Var_y=-sqrt(z^3/(p1-z));
  1900.         z=fn2(z^p3) + p2*(fn3(Var_x) + fn4(Var_y));
  1901.     }
  1902.     bool bailout(void)
  1903.     {
  1904.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  1905.     }
  1906.     void description(void)
  1907.     {
  1908.         this.title="gfp2cod01";
  1909.  
  1910.         p1.caption="Parameter 1";
  1911.         p1.default=(1.0,0.0);
  1912.    
  1913.  
  1914.         p2.caption="Parameter 2";
  1915.         p2.default=(1.0,0.0);
  1916.    
  1917.  
  1918.         p3.caption="Exponent";
  1919.         p3.default=(2.0,0.0);
  1920.    
  1921.  
  1922.         bailout.caption="Bailout";
  1923.         bailout.default=4.0;
  1924.    
  1925.  
  1926.         test.caption = "Bailout Test";
  1927.         test.default = 0;
  1928.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  1929.    
  1930.  
  1931.         fn1.caption="Function 1";
  1932.         fn1.default = "ident" ;
  1933.   
  1934.  
  1935.         fn2.caption="Function 2";
  1936.         fn2.default = "ident" ;
  1937.   
  1938.  
  1939.         fn3.caption="Function 3";
  1940.         fn3.default = "ident" ;
  1941.   
  1942.  
  1943.         fn4.caption="Function 4";
  1944.         fn4.default = "ident" ;
  1945.   
  1946.     }
  1947. }
  1948.  
  1949.  
  1950. comment
  1951. {
  1952. ;The polar equation of the CONCHOID OF NICOMEDES is
  1953. ;r=a*sec(t) +/- b;  [sec=1/cos]
  1954.  
  1955.  
  1956. }
  1957.  
  1958. gfp2con01   {//Formula by Gedeon Peteri, 1999
  1959.              //Based on equation of Conchoid of Nicomedes
  1960. complex c;
  1961. complex Var_x;
  1962. parameter complex p1;
  1963. complex Var_y;
  1964. parameter complex p3;
  1965. parameter complex p2;
  1966. parameter int test;
  1967. parameter real bailout;
  1968.  
  1969.     void init(void)
  1970.     {
  1971.         z=fn1(pixel);
  1972.     }
  1973.     void loop(void)
  1974.     {
  1975.         c=asin(imag(z)/cabs(z));
  1976.         Var_x=z*1/cos(c)+p1;
  1977.         Var_y=z*1/cos(c)-p1;
  1978.         z=fn2(z^p3) + p2*fn3(Var_x)*fn4(Var_y);
  1979.     }
  1980.     bool bailout(void)
  1981.     {
  1982.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  1983.     }
  1984.     void description(void)
  1985.     {
  1986.         this.title="gfp2con01";
  1987.  
  1988.         p1.caption="Parameter 1";
  1989.         p1.default=(1.0,0.0);
  1990.    
  1991.  
  1992.         p2.caption="Parameter 2";
  1993.         p2.default=(1.0,0.0);
  1994.    
  1995.  
  1996.         p3.caption="Exponent";
  1997.         p3.default=(2.0,0.0);
  1998.    
  1999.  
  2000.         bailout.caption="Bailout";
  2001.         bailout.default=4.0;
  2002.    
  2003.  
  2004.         test.caption = "Bailout Test";
  2005.         test.default = 0;
  2006.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2007.    
  2008.  
  2009.         fn1.caption="Function 1";
  2010.         fn1.default = "ident" ;
  2011.   
  2012.  
  2013.         fn2.caption="Function 2";
  2014.         fn2.default = "ident" ;
  2015.   
  2016.  
  2017.         fn3.caption="Function 3";
  2018.         fn3.default = "ident" ;
  2019.   
  2020.  
  2021.         fn4.caption="Function 4";
  2022.         fn4.default = "ident" ;
  2023.   
  2024.     }
  2025. }
  2026.  
  2027.  
  2028. comment
  2029. {
  2030. ;The parametric equations of the CYCLOID are
  2031. ;x=a(t-sin(t)); y=a(1-cos*t))
  2032.  
  2033.  
  2034. }
  2035.  
  2036. gfp2cyc01   {//Formula by Gedeon Peteri, 1999
  2037.              //Based on equation of Cycloid
  2038. complex c;
  2039. complex Var_x;
  2040. complex Var_y;
  2041. parameter complex p1;
  2042. parameter complex p2;
  2043. parameter int test;
  2044. parameter real bailout;
  2045.  
  2046.     void init(void)
  2047.     {
  2048.         z=fn1(pixel);
  2049.     }
  2050.     void loop(void)
  2051.     {
  2052.         c=asin(imag(z)/cabs(z));
  2053.         Var_x=z*(c-sin(c));
  2054.         Var_y=z*(1-cos(c));
  2055.         z=fn2(z^p1) + p2*fn3(Var_x+Var_y);
  2056.     }
  2057.     bool bailout(void)
  2058.     {
  2059.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2060.     }
  2061.     void description(void)
  2062.     {
  2063.         this.title="gfp2cyc01";
  2064.  
  2065.         p1.caption="Exponent";
  2066.         p1.default=(2.0,0.0);
  2067.    
  2068.  
  2069.         p2.caption="Parameter";
  2070.         p2.default=(3.0,1.0);
  2071.    
  2072.  
  2073.         bailout.caption="Bailout";
  2074.         bailout.default=4.0;
  2075.    
  2076.  
  2077.         test.caption = "Bailout Test";
  2078.         test.default = 0;
  2079.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2080.    
  2081.  
  2082.         fn1.caption="Function 1";
  2083.         fn1.default = "ident" ;
  2084.   
  2085.  
  2086.         fn2.caption="Function 2";
  2087.         fn2.default = "ident" ;
  2088.   
  2089.  
  2090.         fn3.caption="Function 3";
  2091.         fn3.default = "ident" ;
  2092.   
  2093.     }
  2094. }
  2095.  
  2096.  
  2097. gfp2cyc02   {//Formula by Gedeon Peteri, 1999
  2098.              //Based on equation of Cycloid
  2099. complex c;
  2100. complex Var_x;
  2101. complex Var_y;
  2102. parameter complex p1;
  2103. parameter complex p2;
  2104. parameter int test;
  2105. parameter real bailout;
  2106.  
  2107.     void init(void)
  2108.     {
  2109.         z=fn1(pixel);
  2110.     }
  2111.     void loop(void)
  2112.     {
  2113.         c=asin(imag(z)/cabs(z));
  2114.         Var_x=z*(c-sin(c));
  2115.         Var_y=z*(1-cos(c));
  2116.         z=fn2(z^p1) + p2*fn3(Var_x/Var_y);
  2117.     }
  2118.     bool bailout(void)
  2119.     {
  2120.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2121.     }
  2122.     void description(void)
  2123.     {
  2124.         this.title="gfp2cyc02";
  2125.  
  2126.         p1.caption="Exponent";
  2127.         p1.default=(2.0,0.0);
  2128.    
  2129.  
  2130.         p2.caption="Parameter";
  2131.         p2.default=(2.0,1.0);
  2132.    
  2133.  
  2134.         bailout.caption="Bailout";
  2135.         bailout.default=4.0;
  2136.    
  2137.  
  2138.         test.caption = "Bailout Test";
  2139.         test.default = 0;
  2140.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2141.    
  2142.  
  2143.         fn1.caption="Function 1";
  2144.         fn1.default = "ident" ;
  2145.   
  2146.  
  2147.         fn2.caption="Function 2";
  2148.         fn2.default = "ident" ;
  2149.   
  2150.  
  2151.         fn3.caption="Function 3";
  2152.         fn3.default = "ident" ;
  2153.   
  2154.     }
  2155. }
  2156.  
  2157.  
  2158. comment
  2159. {
  2160. ;The general equation of a DAMPED VIBRATION CURVE is
  2161. ;y=ae^-kx * sin(bx+c) where k>0.
  2162.  
  2163.  
  2164. }
  2165.  
  2166. gfp2dvc01   {//Formula by Gedeon Peteri, 1999
  2167.              //Based on equation of Damped vibration curve
  2168. complex Var_y;
  2169. parameter complex p1;
  2170. parameter complex p2;
  2171. parameter complex p3;
  2172. parameter int test;
  2173. parameter real bailout;
  2174.  
  2175.     void init(void)
  2176.     {
  2177.         z=fn1(1/pixel);
  2178.     }
  2179.     void loop(void)
  2180.     {
  2181.         Var_y=p1*exp(p2*z)*fn2(p3*z);
  2182.         z=fn3(z*z) - Var_y;
  2183.     }
  2184.     bool bailout(void)
  2185.     {
  2186.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2187.     }
  2188.     void description(void)
  2189.     {
  2190.         this.title="gfp2dvc01";
  2191.  
  2192.         p1.caption="Parameter 1";
  2193.         p1.default=(1.0,0.0);
  2194.    
  2195.  
  2196.         p2.caption="Parameter 2";
  2197.         p2.default=(1.0,0.0);
  2198.    
  2199.  
  2200.         p3.caption="Parameter 3";
  2201.         p3.default=(1.0,0.0);
  2202.    
  2203.  
  2204.         bailout.caption="Bailout";
  2205.         bailout.default=16.0;
  2206.    
  2207.  
  2208.         test.caption = "Bailout Test";
  2209.         test.default = 0;
  2210.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2211.    
  2212.  
  2213.         fn1.caption="Function 1";
  2214.         fn1.default = "ident" ;
  2215.   
  2216.  
  2217.         fn2.caption="Function 2";
  2218.         fn2.default = "ident" ;
  2219.   
  2220.  
  2221.         fn3.caption="Function 3";
  2222.         fn3.default = "ident" ;
  2223.   
  2224.     }
  2225. }
  2226.  
  2227.  
  2228. gfp2dvc02   {//Formula by Gedeon Peteri, 1999
  2229.              //Based on equation of Damped vibration curve
  2230. complex c;
  2231. complex Var_y;
  2232. parameter complex p1;
  2233. parameter complex p2;
  2234. parameter complex p3;
  2235. parameter int test;
  2236. parameter real bailout;
  2237.  
  2238.     void init(void)
  2239.     {
  2240.         z=fn1(1/pixel);
  2241.         c=fn1(1/pixel);
  2242.     }
  2243.     void loop(void)
  2244.     {
  2245.         Var_y=p1*exp(c*z)*fn2(c*z + p2);
  2246.         z=fn3(z^p3) - Var_y;
  2247.     }
  2248.     bool bailout(void)
  2249.     {
  2250.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2251.     }
  2252.     void description(void)
  2253.     {
  2254.         this.title="gfp2dvc02";
  2255.  
  2256.         p1.caption="Parameter 1";
  2257.         p1.default=(1.0,0.0);
  2258.    
  2259.  
  2260.         p2.caption="Parameter 2";
  2261.         p2.default=(1.0,0.0);
  2262.    
  2263.  
  2264.         p3.caption="Parameter 3";
  2265.         p3.default=(1.0,0.0);
  2266.    
  2267.  
  2268.         bailout.caption="Bailout";
  2269.         bailout.default=16.0;
  2270.    
  2271.  
  2272.         test.caption = "Bailout Test";
  2273.         test.default = 0;
  2274.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2275.    
  2276.  
  2277.         fn1.caption="Function 1";
  2278.         fn1.default = "ident" ;
  2279.   
  2280.  
  2281.         fn2.caption="Function 2";
  2282.         fn2.default = "ident" ;
  2283.   
  2284.  
  2285.         fn3.caption="Function 3";
  2286.         fn3.default = "ident" ;
  2287.   
  2288.     }
  2289. }
  2290.  
  2291.  
  2292. comment
  2293. {
  2294. ;The parametric equations of the FOLIUM OF DESCARTES are
  2295. ;x=3at/(1+t^3), y=3at^2/(1+t^3); let p1=3a
  2296.  
  2297.  
  2298. }
  2299.  
  2300. gfp2fod01   {//Formula by Gedeon Peteri, 1999
  2301.              //Based on equation of Folium of Descartes
  2302. complex Var_x;
  2303. parameter complex p1;
  2304. complex Var_y;
  2305. parameter complex p3;
  2306. parameter complex p2;
  2307. parameter int test;
  2308. parameter real bailout;
  2309.  
  2310.     void init(void)
  2311.     {
  2312.         z=fn1(pixel);
  2313.     }
  2314.     void loop(void)
  2315.     {
  2316.         Var_x=p1*z/(1+z*z*z);
  2317.         Var_y=p1*z*z/(1+z*z*z);
  2318.         z=fn1(z^p3) + p2*(fn2(Var_x) + fn3(Var_y));
  2319.     }
  2320.     bool bailout(void)
  2321.     {
  2322.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2323.     }
  2324.     void description(void)
  2325.     {
  2326.         this.title="gfp2fod01";
  2327.  
  2328.         p1.caption="Parameter 1";
  2329.         p1.default=(1.0,0.0);
  2330.    
  2331.  
  2332.         p2.caption="Parameter 2";
  2333.         p2.default=(1.0,0.0);
  2334.    
  2335.  
  2336.         p3.caption="Exponent";
  2337.         p3.default=(2.0,0.0);
  2338.    
  2339.  
  2340.         bailout.caption="Bailout";
  2341.         bailout.default=4.0;
  2342.    
  2343.  
  2344.         test.caption = "Bailout Test";
  2345.         test.default = 0;
  2346.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2347.    
  2348.  
  2349.         fn1.caption="Function 1";
  2350.         fn1.default = "recip" ;
  2351.   
  2352.  
  2353.         fn2.caption="Function 2";
  2354.         fn2.default = "ident" ;
  2355.   
  2356.  
  2357.         fn3.caption="Function 3";
  2358.         fn3.default = "ident" ;
  2359.   
  2360.     }
  2361. }
  2362.  
  2363.  
  2364. gfp2fod02   {//Formula by Gedeon Peteri, 1999
  2365.              //Based on equation of Folium of Descartes
  2366. complex c;
  2367. complex Var_x;
  2368. parameter complex p1;
  2369. complex Var_y;
  2370. parameter complex p3;
  2371. parameter complex p2;
  2372. parameter int test;
  2373. parameter real bailout;
  2374.  
  2375.     void init(void)
  2376.     {
  2377.         z=fn1(pixel);
  2378.     }
  2379.     void loop(void)
  2380.     {
  2381.         c=asin(imag(z)/cabs(z));
  2382.         Var_x=p1*z/(1+z*z*z);
  2383.         Var_y=p1*z*z/(1+z*z*z);
  2384.         z=fn1(z^p3) + p2*(fn2(Var_x*c) + fn3(Var_y*c));
  2385.     }
  2386.     bool bailout(void)
  2387.     {
  2388.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2389.     }
  2390.     void description(void)
  2391.     {
  2392.         this.title="gfp2fod02";
  2393.  
  2394.         p1.caption="Parameter 1";
  2395.         p1.default=(1.0,0.0);
  2396.    
  2397.  
  2398.         p2.caption="Parameter 2";
  2399.         p2.default=(1.0,0.0);
  2400.    
  2401.  
  2402.         p3.caption="Exponent";
  2403.         p3.default=(2.0,0.0);
  2404.    
  2405.  
  2406.         bailout.caption="Bailout";
  2407.         bailout.default=4.0;
  2408.    
  2409.  
  2410.         test.caption = "Bailout Test";
  2411.         test.default = 0;
  2412.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2413.    
  2414.  
  2415.         fn1.caption="Function 1";
  2416.         fn1.default = "recip" ;
  2417.   
  2418.  
  2419.         fn2.caption="Function 2";
  2420.         fn2.default = "ident" ;
  2421.   
  2422.  
  2423.         fn3.caption="Function 3";
  2424.         fn3.default = "ident" ;
  2425.   
  2426.     }
  2427. }
  2428.  
  2429.  
  2430. comment
  2431. {
  2432. ;HYPERBOLIC SPIRAL r*t=a [or r=a/t] and its first derivative r'=-a/(t^2)
  2433.  
  2434.  
  2435. }
  2436.  
  2437. gfp2hsp01   {//Formula by Gedeon Peteri, 1999
  2438.              //Based on equation of Hyperbolic spiral
  2439. parameter complex p1;
  2440. parameter complex p2;
  2441. parameter complex p3;
  2442. parameter int test;
  2443. parameter real bailout;
  2444.  
  2445.     void init(void)
  2446.     {
  2447.         z=fn1(pixel);
  2448.     }
  2449.     void loop(void)
  2450.     {
  2451.         z=fn2(z^p1) + p2*fn3(-p3/(z*z));
  2452.     }
  2453.     bool bailout(void)
  2454.     {
  2455.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2456.     }
  2457.     void description(void)
  2458.     {
  2459.         this.title="gfp2hsp01";
  2460.  
  2461.         p1.caption="Exponent";
  2462.         p1.default=(2.0,0.0);
  2463.    
  2464.  
  2465.         p2.caption="Parameter 1";
  2466.         p2.default=(1.0,0.0);
  2467.    
  2468.  
  2469.         p3.caption="Parameter 2";
  2470.         p3.default=(1.0,0.0);
  2471.    
  2472.  
  2473.         bailout.caption="Bailout";
  2474.         bailout.default=4.0;
  2475.    
  2476.  
  2477.         test.caption = "Bailout Test";
  2478.         test.default = 0;
  2479.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2480.    
  2481.  
  2482.         fn1.caption="Function 1";
  2483.         fn1.default = "ident" ;
  2484.   
  2485.  
  2486.         fn2.caption="Function 2";
  2487.         fn2.default = "ident" ;
  2488.   
  2489.  
  2490.         fn3.caption="Function 3";
  2491.         fn3.default = "ident" ;
  2492.   
  2493.     }
  2494. }
  2495.  
  2496.  
  2497. comment
  2498. {
  2499. ;The parametric equations of the HYPOCYCLOID are
  2500. ;x=(a-b)cos(t)+b*cos((a-b)/b*t)
  2501. ;y=(a-b)sin(t)-b*sin((a-b)/b*t)
  2502.  
  2503.  
  2504. }
  2505.  
  2506. gfp2hyc01   {//Formula by Gedeon Peteri, 1999
  2507.              //Based on equations of the Hypocycloid
  2508. complex a;
  2509. parameter complex p2;
  2510. complex b;
  2511. complex c;
  2512. complex Var_x;
  2513. complex Var_y;
  2514. parameter complex p1;
  2515. parameter complex p3;
  2516. parameter int test;
  2517. parameter real bailout;
  2518.  
  2519.     void init(void)
  2520.     {
  2521.         z=fn1(pixel);
  2522.         a=real(p2);
  2523.         b=imag(p2);
  2524.     }
  2525.     void loop(void)
  2526.     {
  2527.         c=asin(imag(z)/cabs(z));
  2528.         Var_x=(a-b)*cos(c)+b*cos(((a-b)/b)*c);
  2529.         Var_y=(a-b)*sin(c)-b*sin(((a-b)/b)*c);
  2530.         z=fn2(z^p1) + p3*fn3(Var_x+Var_y);
  2531.     }
  2532.     bool bailout(void)
  2533.     {
  2534.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2535.     }
  2536.     void description(void)
  2537.     {
  2538.         this.title="gfp2hyc01";
  2539.  
  2540.         p1.caption="Exponent";
  2541.         p1.default=(2.0,0.0);
  2542.    
  2543.  
  2544.         p2.caption="Parameter 1";
  2545.         p2.default=(1.0,0.5);
  2546.    
  2547.  
  2548.         p3.caption="Parameter 2";
  2549.         p3.default=(1.0,0.0);
  2550.    
  2551.  
  2552.         bailout.caption="Bailout";
  2553.         bailout.default=4.0;
  2554.    
  2555.  
  2556.         test.caption = "Bailout Test";
  2557.         test.default = 0;
  2558.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2559.    
  2560.  
  2561.         fn1.caption="Function 1";
  2562.         fn1.default = "ident" ;
  2563.   
  2564.  
  2565.         fn2.caption="Function 2";
  2566.         fn2.default = "ident" ;
  2567.   
  2568.  
  2569.         fn3.caption="Function 3";
  2570.         fn3.default = "ident" ;
  2571.   
  2572.     }
  2573. }
  2574.  
  2575.  
  2576. comment
  2577. {
  2578. ;The parametric equations of the Involute of a circle are
  2579. ;x=a*cos(t)+at*sin(t); y=a*sin(t)-at*cos(t)
  2580.  
  2581.  
  2582. }
  2583.  
  2584. gfp2inc01   {//Formula by Gedeon Peteri, 1999
  2585.              //Based on equations of the Involute of a circle
  2586. complex c;
  2587. complex Var_x;
  2588. parameter complex p2;
  2589. complex Var_y;
  2590. parameter complex p1;
  2591. parameter complex p3;
  2592. parameter int test;
  2593. parameter real bailout;
  2594.  
  2595.     void init(void)
  2596.     {
  2597.         z=fn1(pixel);
  2598.     }
  2599.     void loop(void)
  2600.     {
  2601.         c=asin(imag(z)/cabs(z));
  2602.         Var_x=p2*cos(c)+p2*c*sin(c);
  2603.         Var_y=p2*sin(c)-p2*c*cos(c);
  2604.         z=fn2(z^p1) + p3*fn3(Var_x+Var_y);
  2605.     }
  2606.     bool bailout(void)
  2607.     {
  2608.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2609.     }
  2610.     void description(void)
  2611.     {
  2612.         this.title="gfp2inc01";
  2613.  
  2614.         p1.caption="Exponent";
  2615.         p1.default=(2.0,0.0);
  2616.    
  2617.  
  2618.         p2.caption="Parameter 1";
  2619.         p2.default=(0.5,0.0);
  2620.    
  2621.  
  2622.         p3.caption="Parameter 2";
  2623.         p3.default=(1.0,0.0);
  2624.    
  2625.  
  2626.         bailout.caption="Bailout";
  2627.         bailout.default=4.0;
  2628.    
  2629.  
  2630.         test.caption = "Bailout Test";
  2631.         test.default = 0;
  2632.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2633.    
  2634.  
  2635.         fn1.caption="Function 1";
  2636.         fn1.default = "ident" ;
  2637.   
  2638.  
  2639.         fn2.caption="Function 2";
  2640.         fn2.default = "ident" ;
  2641.   
  2642.  
  2643.         fn3.caption="Function 3";
  2644.         fn3.default = "ident" ;
  2645.   
  2646.     }
  2647. }
  2648.  
  2649.  
  2650. comment
  2651. {
  2652. ;The equation for the LEMNISCATE OF BERNOULLI is
  2653. ;(x^2+y^2)^2 = 2a^2(x^2-y^2), or 2a^2(x^2-y^2)-(x^2+y^2)^2 = 0
  2654.  
  2655.  
  2656. }
  2657.  
  2658. gfp2lob01   {//Formula by Gedeon Peteri, 1999
  2659.              //Based on equation of Lemniscate of Bernoulli
  2660. complex Var_x;
  2661. complex Var_y;
  2662. parameter complex p1;
  2663. parameter complex p2;
  2664. parameter int test;
  2665. parameter real bailout;
  2666.  
  2667.     void init(void)
  2668.     {
  2669.         z=fn1(pixel);
  2670.         Var_x=real(z);
  2671.         Var_y=imag(z);
  2672.     }
  2673.     void loop(void)
  2674.     {
  2675.         z=fn2(z^p1)+p2*fn3(Var_x*Var_x-Var_y*Var_y-sqr(Var_x*Var_x+Var_y*Var_y));
  2676.     }
  2677.     bool bailout(void)
  2678.     {
  2679.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2680.     }
  2681.     void description(void)
  2682.     {
  2683.         this.title="gfp2lob01";
  2684.  
  2685.         p1.caption="Exponent";
  2686.         p1.default=(2.0,0.0);
  2687.    
  2688.  
  2689.         p2.caption="Parameter";
  2690.         p2.default=(1.0,0.0);
  2691.    
  2692.  
  2693.         bailout.caption="Bailout";
  2694.         bailout.default=4.0;
  2695.    
  2696.  
  2697.         test.caption = "Bailout Test";
  2698.         test.default = 0;
  2699.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2700.    
  2701.  
  2702.         fn1.caption="Function 1";
  2703.         fn1.default = "ident" ;
  2704.   
  2705.  
  2706.         fn2.caption="Function 2";
  2707.         fn2.default = "ident" ;
  2708.   
  2709.  
  2710.         fn3.caption="Function 3";
  2711.         fn3.default = "ident" ;
  2712.   
  2713.     }
  2714. }
  2715.  
  2716.  
  2717. gfp2lob02   {//Formula by Gedeon Peteri, 1999
  2718.              //Based on equation of Lemniscate of Bernoulli
  2719. complex Var_x;
  2720. complex Var_y;
  2721. complex c;
  2722. parameter complex p1;
  2723. parameter complex p2;
  2724. parameter int test;
  2725. parameter real bailout;
  2726.  
  2727.     void init(void)
  2728.     {
  2729.         z=fn1(pixel);
  2730.         Var_x=real(z);
  2731.         Var_y=imag(z);
  2732.     }
  2733.     void loop(void)
  2734.     {
  2735.         c=asin(imag(z)/cabs(z));
  2736.         z=fn2(z^p1)+p2*(fn3(c)*fn4(Var_x*Var_x-Var_y*Var_y-sqr(Var_x*Var_x+Var_y*Var_y)));
  2737.     }
  2738.     bool bailout(void)
  2739.     {
  2740.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2741.     }
  2742.     void description(void)
  2743.     {
  2744.         this.title="gfp2lob02";
  2745.  
  2746.         p1.caption="Exponent";
  2747.         p1.default=(2.0,0.0);
  2748.    
  2749.  
  2750.         p2.caption="Parameter";
  2751.         p2.default=(1.0,0.0);
  2752.    
  2753.  
  2754.         bailout.caption="Bailout";
  2755.         bailout.default=4.0;
  2756.    
  2757.  
  2758.         test.caption = "Bailout Test";
  2759.         test.default = 0;
  2760.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2761.    
  2762.  
  2763.         fn1.caption="Function 1";
  2764.         fn1.default = "ident" ;
  2765.   
  2766.  
  2767.         fn2.caption="Function 2";
  2768.         fn2.default = "ident" ;
  2769.   
  2770.  
  2771.         fn3.caption="Function 3";
  2772.         fn3.default = "ident" ;
  2773.   
  2774.  
  2775.         fn4.caption="Function 4";
  2776.         fn4.default = "ident" ;
  2777.   
  2778.     }
  2779. }
  2780.  
  2781.  
  2782. gfp2lob03   {//Formula by Gedeon Peteri, 1999
  2783.              //Based on equation of Lemniscate of Bernoulli
  2784. complex Var_x;
  2785. complex Var_y;
  2786. complex c;
  2787. parameter complex p1;
  2788. parameter complex p2;
  2789. parameter int test;
  2790. parameter real bailout;
  2791.  
  2792.     void init(void)
  2793.     {
  2794.         z=fn1(pixel);
  2795.         Var_x=real(z);
  2796.         Var_y=imag(z);
  2797.     }
  2798.     void loop(void)
  2799.     {
  2800.         c=asin(imag(z)/cabs(z));
  2801.         z=fn2(z^p1)+p2*(fn3(cos(c))*fn4(Var_x*Var_x-Var_y*Var_y-sqr(Var_x*Var_x+Var_y*Var_y)));
  2802.     }
  2803.     bool bailout(void)
  2804.     {
  2805.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2806.     }
  2807.     void description(void)
  2808.     {
  2809.         this.title="gfp2lob03";
  2810.  
  2811.         p1.caption="Exponent";
  2812.         p1.default=(2.0,0.0);
  2813.    
  2814.  
  2815.         p2.caption="Parameter";
  2816.         p2.default=(1.0,0.0);
  2817.    
  2818.  
  2819.         bailout.caption="Bailout";
  2820.         bailout.default=4.0;
  2821.    
  2822.  
  2823.         test.caption = "Bailout Test";
  2824.         test.default = 0;
  2825.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2826.    
  2827.  
  2828.         fn1.caption="Function 1";
  2829.         fn1.default = "ident" ;
  2830.   
  2831.  
  2832.         fn2.caption="Function 2";
  2833.         fn2.default = "ident" ;
  2834.   
  2835.  
  2836.         fn3.caption="Function 3";
  2837.         fn3.default = "ident" ;
  2838.   
  2839.  
  2840.         fn4.caption="Function 4";
  2841.         fn4.default = "ident" ;
  2842.   
  2843.     }
  2844. }
  2845.  
  2846.  
  2847. comment
  2848. {
  2849. ;The polar equation of the LIMACON OF PASCAL is
  2850. ;r=2a*cos(t)+b
  2851.  
  2852.  
  2853. }
  2854.  
  2855. gfp2lop01   {//Formula by Gedeon Peteri, 1999
  2856.              //Based on equation of Limacon of Pascal
  2857. parameter complex p1;
  2858. parameter complex p2;
  2859. parameter complex p3;
  2860. parameter int test;
  2861. parameter real bailout;
  2862.  
  2863.     void init(void)
  2864.     {
  2865.         z=fn1(pixel);
  2866.     }
  2867.     void loop(void)
  2868.     {
  2869.         z=fn2(z^p1) + fn3(2*p2*cos(z)+p3);
  2870.     }
  2871.     bool bailout(void)
  2872.     {
  2873.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2874.     }
  2875.     void description(void)
  2876.     {
  2877.         this.title="gfp2lop01";
  2878.  
  2879.         p1.caption="Exponent";
  2880.         p1.default=(1.0,0.0);
  2881.    
  2882.  
  2883.         p2.caption="Parameter 1";
  2884.         p2.default=(0.01,0.0);
  2885.    
  2886.  
  2887.         p3.caption="Parameter 2";
  2888.         p3.default=(2.0,0.0);
  2889.    
  2890.  
  2891.         bailout.caption="Bailout";
  2892.         bailout.default=4.0;
  2893.    
  2894.  
  2895.         test.caption = "Bailout Test";
  2896.         test.default = 0;
  2897.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2898.    
  2899.  
  2900.         fn1.caption="Function 1";
  2901.         fn1.default = "ident" ;
  2902.   
  2903.  
  2904.         fn2.caption="Function 2";
  2905.         fn2.default = "ident" ;
  2906.   
  2907.  
  2908.         fn3.caption="Function 3";
  2909.         fn3.default = "ident" ;
  2910.   
  2911.     }
  2912. }
  2913.  
  2914.  
  2915. comment
  2916. {
  2917. ;LOGARITHMIC SPIRAL r=e^(a*t) and first derivative r'=e^(a*t) * log e * a
  2918.  
  2919.  
  2920. }
  2921.  
  2922. gfp2lsp01   {//Formula by Gedeon Peteri, 1999
  2923.              //Based on equation of Logarithmic spiral
  2924. parameter complex p1;
  2925. parameter complex p2;
  2926. parameter complex p3;
  2927. parameter int test;
  2928. parameter real bailout;
  2929.  
  2930.     void init(void)
  2931.     {
  2932.         z=fn1(pixel);
  2933.     }
  2934.     void loop(void)
  2935.     {
  2936.         z=fn2(z^p1) + p2*fn3(exp(p3*z));
  2937.     }
  2938.     bool bailout(void)
  2939.     {
  2940.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  2941.     }
  2942.     void description(void)
  2943.     {
  2944.         this.title="gfp2lsp01";
  2945.  
  2946.         p1.caption="Exponent";
  2947.         p1.default=(2.0,0.0);
  2948.    
  2949.  
  2950.         p2.caption="Parameter 1";
  2951.         p2.default=(1.0,0.0);
  2952.    
  2953.  
  2954.         p3.caption="Parameter 2";
  2955.         p3.default=(1.0,0.0);
  2956.    
  2957.  
  2958.         bailout.caption="Bailout";
  2959.         bailout.default=4.0;
  2960.    
  2961.  
  2962.         test.caption = "Bailout Test";
  2963.         test.default = 0;
  2964.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  2965.    
  2966.  
  2967.         fn1.caption="Function 1";
  2968.         fn1.default = "ident" ;
  2969.   
  2970.  
  2971.         fn2.caption="Function 2";
  2972.         fn2.default = "ident" ;
  2973.   
  2974.  
  2975.         fn3.caption="Function 3";
  2976.         fn3.default = "ident" ;
  2977.   
  2978.     }
  2979. }
  2980.  
  2981.  
  2982. gfp2lsp02   {//Formula by Gedeon Peteri, 1999
  2983.              //Based on equation of Logarithmic spiral
  2984. parameter complex p1;
  2985. parameter complex p2;
  2986. parameter complex p3;
  2987. parameter int test;
  2988. parameter real bailout;
  2989.  
  2990.     void init(void)
  2991.     {
  2992.         z=fn1(pixel);
  2993.     }
  2994.     void loop(void)
  2995.     {
  2996.         z=fn2(z^p1) + p2*fn3(exp(p3*z)*log(e*p3));
  2997.     }
  2998.     bool bailout(void)
  2999.     {
  3000.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3001.     }
  3002.     void description(void)
  3003.     {
  3004.         this.title="gfp2lsp02";
  3005.  
  3006.         p1.caption="Exponent";
  3007.         p1.default=(2.0,0.0);
  3008.    
  3009.  
  3010.         p2.caption="Parameter 1";
  3011.         p2.default=(1.0,0.0);
  3012.    
  3013.  
  3014.         p3.caption="Parameter 2";
  3015.         p3.default=(1.0,0.0);
  3016.    
  3017.  
  3018.         bailout.caption="Bailout";
  3019.         bailout.default=4.0;
  3020.    
  3021.  
  3022.         test.caption = "Bailout Test";
  3023.         test.default = 0;
  3024.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3025.    
  3026.  
  3027.         fn1.caption="Function 1";
  3028.         fn1.default = "ident" ;
  3029.   
  3030.  
  3031.         fn2.caption="Function 2";
  3032.         fn2.default = "ident" ;
  3033.   
  3034.  
  3035.         fn3.caption="Function 3";
  3036.         fn3.default = "ident" ;
  3037.   
  3038.     }
  3039. }
  3040.  
  3041.  
  3042. comment
  3043. {
  3044. ;The equation of the PROBABILITY CURVE is
  3045. ;y=e^(-x^2/2)/(2*pi)^(1/2)
  3046.  
  3047.  
  3048. }
  3049.  
  3050. gfp2pro01   {//Formula by Gedeon Peteri, 1999
  3051.              //Based on equation of Probability curve
  3052. parameter complex p1;
  3053. parameter complex p2;
  3054. parameter int test;
  3055. parameter real bailout;
  3056.  
  3057.     void init(void)
  3058.     {
  3059.         z=fn1(pixel);
  3060.     }
  3061.     void loop(void)
  3062.     {
  3063.         z=fn2(z^p1)-p2*fn3(exp(-z*z/2)/sqrt(6.28318530718));
  3064.     }
  3065.     bool bailout(void)
  3066.     {
  3067.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3068.     }
  3069.     void description(void)
  3070.     {
  3071.         this.title="gfp2pro01";
  3072.  
  3073.         p1.caption="Exponent";
  3074.         p1.default=(2.0,0.0);
  3075.    
  3076.  
  3077.         p2.caption="Parameter";
  3078.         p2.default=(1.0,0.0);
  3079.    
  3080.  
  3081.         bailout.caption="Bailout";
  3082.         bailout.default=4.0;
  3083.    
  3084.  
  3085.         test.caption = "Bailout Test";
  3086.         test.default = 0;
  3087.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3088.    
  3089.  
  3090.         fn1.caption="Function 1";
  3091.         fn1.default = "ident" ;
  3092.   
  3093.  
  3094.         fn2.caption="Function 2";
  3095.         fn2.default = "ident" ;
  3096.   
  3097.  
  3098.         fn3.caption="Function 3";
  3099.         fn3.default = "ident" ;
  3100.   
  3101.     }
  3102. }
  3103.  
  3104.  
  3105. comment
  3106. {
  3107. ;The polar equations of the ROSE-LEAVED CURVES are
  3108. ;r=a*sin(nt); and r=a*cos(nt)); if n is even curve has 2n loops
  3109.  
  3110.  
  3111. }
  3112.  
  3113. gfp2ros01   {//Formula by Gedeon Peteri, 1999
  3114.              //Based on equation of Rose-leaved curve
  3115. complex c;
  3116. parameter complex p1;
  3117. parameter complex p2;
  3118. parameter complex p3;
  3119. parameter int test;
  3120. parameter real bailout;
  3121.  
  3122.     void init(void)
  3123.     {
  3124.         z=fn1(pixel);
  3125.     }
  3126.     void loop(void)
  3127.     {
  3128.         c=asin(imag(z)/cabs(z));
  3129.         z=fn2(z^p1) + p2*fn3(sin(p3*c));
  3130.     }
  3131.     bool bailout(void)
  3132.     {
  3133.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3134.     }
  3135.     void description(void)
  3136.     {
  3137.         this.title="gfp2ros01";
  3138.  
  3139.         p1.caption="Exponent";
  3140.         p1.default=(2.0,0.0);
  3141.    
  3142.  
  3143.         p2.caption="Parameter 1";
  3144.         p2.default=(1.0,0.0);
  3145.    
  3146.  
  3147.         p3.caption="Parameter 2";
  3148.         p3.default=(1.0,0.0);
  3149.    
  3150.  
  3151.         bailout.caption="Bailout";
  3152.         bailout.default=4.0;
  3153.    
  3154.  
  3155.         test.caption = "Bailout Test";
  3156.         test.default = 0;
  3157.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3158.    
  3159.  
  3160.         fn1.caption="Function 1";
  3161.         fn1.default = "ident" ;
  3162.   
  3163.  
  3164.         fn2.caption="Function 2";
  3165.         fn2.default = "ident" ;
  3166.   
  3167.  
  3168.         fn3.caption="Function 3";
  3169.         fn3.default = "ident" ;
  3170.   
  3171.     }
  3172. }
  3173.  
  3174.  
  3175. comment
  3176. {
  3177. ;Some simple algebraic curves
  3178.  
  3179.  
  3180. }
  3181.  
  3182. gfp2sac01   {//Formula by Gedeon Peteri, 1999
  3183.              //Based on equation y^2=(x-1)(x-2)(x-3)
  3184. complex a;
  3185. parameter complex p1;
  3186. parameter complex p2;
  3187. parameter int test;
  3188. parameter real bailout;
  3189.  
  3190.     void init(void)
  3191.     {
  3192.         z=fn1(pixel);
  3193.         a=p1;
  3194.     }
  3195.     void loop(void)
  3196.     {
  3197.         z=fn2(z^a) + p2*fn3(sqrt((z-1)*(z-2)*(z-3)));
  3198.     }
  3199.     bool bailout(void)
  3200.     {
  3201.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3202.     }
  3203.     void description(void)
  3204.     {
  3205.         this.title="gfp2sac01";
  3206.  
  3207.         p1.caption="Exponent";
  3208.         p1.default=(2.0,0.0);
  3209.    
  3210.  
  3211.         p2.caption="Parameter";
  3212.         p2.default=(0.5,0.0);
  3213.    
  3214.  
  3215.         bailout.caption="Bailout";
  3216.         bailout.default=4.0;
  3217.    
  3218.  
  3219.         test.caption = "Bailout Test";
  3220.         test.default = 0;
  3221.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3222.    
  3223.  
  3224.         fn1.caption="Function 1";
  3225.         fn1.default = "ident" ;
  3226.   
  3227.  
  3228.         fn2.caption="Function 2";
  3229.         fn2.default = "ident" ;
  3230.   
  3231.  
  3232.         fn3.caption="Function 3";
  3233.         fn3.default = "ident" ;
  3234.   
  3235.     }
  3236. }
  3237.  
  3238.  
  3239. comment
  3240. {
  3241. ;The parametric equations of the STROPHOID are
  3242. ;x=+/-a*sinw, y=a*tanw*(1 +/- sinw)
  3243.  
  3244.  
  3245. }
  3246.  
  3247. gfp2str01   {//Formula by Gedeon Peteri, 1999
  3248.              //Based on equation of Strophoid
  3249. complex Var_x;
  3250. parameter complex p1;
  3251. complex Var_y;
  3252. parameter complex p3;
  3253. parameter complex p2;
  3254. parameter int test;
  3255. parameter real bailout;
  3256.  
  3257.     void init(void)
  3258.     {
  3259.         z=fn1(pixel);
  3260.     }
  3261.     void loop(void)
  3262.     {
  3263.         Var_x=p1*sin(z);
  3264.         Var_y=p1*(tan(z)*(1-sin(z)));
  3265.         z=fn2(z^p3) + p2*((fn3(Var_x) + fn4(Var_y)));
  3266.     }
  3267.     bool bailout(void)
  3268.     {
  3269.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3270.     }
  3271.     void description(void)
  3272.     {
  3273.         this.title="gfp2str01";
  3274.  
  3275.         p1.caption="Parameter 1";
  3276.         p1.default=(0.4,0.4);
  3277.    
  3278.  
  3279.         p2.caption="Parameter 2";
  3280.         p2.default=(-1.0,0.0);
  3281.    
  3282.  
  3283.         p3.caption="Exponent";
  3284.         p3.default=(2.0,0.0);
  3285.    
  3286.  
  3287.         bailout.caption="Bailout";
  3288.         bailout.default=4.0;
  3289.    
  3290.  
  3291.         test.caption = "Bailout Test";
  3292.         test.default = 0;
  3293.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3294.    
  3295.  
  3296.         fn1.caption="Function 1";
  3297.         fn1.default = "ident" ;
  3298.   
  3299.  
  3300.         fn2.caption="Function 2";
  3301.         fn2.default = "ident" ;
  3302.   
  3303.  
  3304.         fn3.caption="Function 3";
  3305.         fn3.default = "ident" ;
  3306.   
  3307.  
  3308.         fn4.caption="Function 4";
  3309.         fn4.default = "ident" ;
  3310.   
  3311.     }
  3312. }
  3313.  
  3314.  
  3315. comment
  3316. {
  3317. ;Parametric equations of the WITCH OF AGNESI are
  3318. ;x=a*cot alpha, y=a*sin^2 alpha
  3319.  
  3320.  
  3321. }
  3322.  
  3323. gfp2woa01   {//Formula by Gedeon Peteri, 1999
  3324.              //Based on equation of Witch of Agnesi
  3325. complex Var_x;
  3326. parameter complex p1;
  3327. complex Var_y;
  3328. parameter complex p3;
  3329. parameter complex p2;
  3330. parameter int test;
  3331. parameter real bailout;
  3332.  
  3333.     void init(void)
  3334.     {
  3335.         z=fn1(pixel);
  3336.     }
  3337.     void loop(void)
  3338.     {
  3339.         Var_x=p1*cotan(z);
  3340.         Var_y=p1*sin(z)*sin(z);
  3341.         z=fn2(z^p3) + p2*(fn3(Var_x)+fn4(Var_y));
  3342.     }
  3343.     bool bailout(void)
  3344.     {
  3345.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3346.     }
  3347.     void description(void)
  3348.     {
  3349.         this.title="gfp2woa01";
  3350.  
  3351.         p1.caption="Parameter 1";
  3352.         p1.default=(0.2,0.0);
  3353.    
  3354.  
  3355.         p2.caption="Parameter 2";
  3356.         p2.default=(1.0,0.0);
  3357.    
  3358.  
  3359.         p3.caption="Exponent";
  3360.         p3.default=(2.0,0.0);
  3361.    
  3362.  
  3363.         bailout.caption="Bailout";
  3364.         bailout.default=4.0;
  3365.    
  3366.  
  3367.         test.caption = "Bailout Test";
  3368.         test.default = 0;
  3369.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3370.    
  3371.  
  3372.         fn1.caption="Function 1";
  3373.         fn1.default = "ident" ;
  3374.   
  3375.  
  3376.         fn2.caption="Function 2";
  3377.         fn2.default = "ident" ;
  3378.   
  3379.  
  3380.         fn3.caption="Function 3";
  3381.         fn3.default = "ident" ;
  3382.   
  3383.  
  3384.         fn4.caption="Function 4";
  3385.         fn4.default = "ident" ;
  3386.   
  3387.     }
  3388. }
  3389.  
  3390.  
  3391. gfp2woa02   {//Formula by Gedeon Peteri, 1999
  3392.              //Based on equation of Witch of Agnesi
  3393. complex Var_x;
  3394. parameter complex p1;
  3395. complex Var_y;
  3396. parameter complex p3;
  3397. parameter complex p2;
  3398. parameter int test;
  3399. parameter real bailout;
  3400.  
  3401.     void init(void)
  3402.     {
  3403.         z=fn1(pixel);
  3404.     }
  3405.     void loop(void)
  3406.     {
  3407.         Var_x=p1*cotan(z);
  3408.         Var_y=p1*sin(z)*sin(z);
  3409.         z=fn2(z^p3) + p2*(fn3(Var_x)*fn4(Var_y));
  3410.     }
  3411.     bool bailout(void)
  3412.     {
  3413.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3414.     }
  3415.     void description(void)
  3416.     {
  3417.         this.title="gfp2woa02";
  3418.  
  3419.         p1.caption="Parameter 1";
  3420.         p1.default=(1.0,0.0);
  3421.    
  3422.  
  3423.         p2.caption="Parameter 2";
  3424.         p2.default=(1.0,0.0);
  3425.    
  3426.  
  3427.         p3.caption="Exponent";
  3428.         p3.default=(2.0,0.0);
  3429.    
  3430.  
  3431.         bailout.caption="Bailout";
  3432.         bailout.default=4.0;
  3433.    
  3434.  
  3435.         test.caption = "Bailout Test";
  3436.         test.default = 0;
  3437.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3438.    
  3439.  
  3440.         fn1.caption="Function 1";
  3441.         fn1.default = "ident" ;
  3442.   
  3443.  
  3444.         fn2.caption="Function 2";
  3445.         fn2.default = "ident" ;
  3446.   
  3447.  
  3448.         fn3.caption="Function 3";
  3449.         fn3.default = "ident" ;
  3450.   
  3451.  
  3452.         fn4.caption="Function 4";
  3453.         fn4.default = "ident" ;
  3454.   
  3455.     }
  3456. }
  3457.  
  3458.  
  3459. gp-hyc       {//Formula by Gedeon Peteri, 2000
  3460.               //Based on the parametric equations of the
  3461.               //HYPOCYCLOID
  3462.   //x = (a-b)cos(t) + b*cos((a-b)/b*t)
  3463.   //y = (a-b)sin(t) - b*sin((a-b)/b*t)
  3464. complex w;
  3465. complex Var_x;
  3466. parameter complex a;
  3467. parameter complex b;
  3468. complex Var_y;
  3469. parameter int var;
  3470. parameter complex exp;
  3471. parameter complex c;
  3472. parameter int test;
  3473. parameter real bailout;
  3474.  
  3475.     void init(void)
  3476.     {
  3477.         z = pfunc(pixel);
  3478.     }
  3479.     void loop(void)
  3480.     {
  3481.         w = asin(imag(z)/cabs(z));
  3482.         Var_x = (a-b)*cos(w) + b*cos(((a-b)/b)*w);
  3483.         Var_y = (a-b)*sin(w) - b*sin(((a-b)/b)*w);
  3484.         if  ((var == 0))
  3485.         {//Variation 1
  3486.             z = lfunc1(z^exp) + c*lfunc2(Var_x + Var_y);
  3487.         }
  3488.         else if  ((var == 1))
  3489.         {//Variation 2
  3490.             z = lfunc1(z^exp) + c*lfunc2(Var_x + flip(Var_y));
  3491.         }
  3492.     }
  3493.     bool bailout(void)
  3494.     {
  3495.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3496.     }
  3497.     void description(void)
  3498.     {
  3499.         this.title = "gp-hyc";
  3500.         this.maxiter = 500;
  3501.         this.periodicity = 0;
  3502.         this.center = (-1.0,1.0);
  3503.         this.magn = 2.5;
  3504.  
  3505.         exp.caption = "Exponent";
  3506.         exp.default = (2.0,0.0);
  3507.    
  3508.  
  3509.         a.caption = "Parameter 1";
  3510.         a.default = (0.65,0.0);
  3511.    
  3512.  
  3513.         b.caption = "Parameter 2";
  3514.         b.default = (0.35,0.0);
  3515.    
  3516.  
  3517.         c.caption = "Parameter 3";
  3518.         c.default = (0.67,0.33);
  3519.    
  3520.  
  3521.         bailout.caption = "Bailout value";
  3522.         bailout.default = 8.0;
  3523.    
  3524.  
  3525.         test.caption = "Bailout test";
  3526.         test.default = 0;
  3527.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3528.    
  3529.  
  3530.         var.caption = "Variations";
  3531.         var.default = 0;
  3532.         var.enum = "Variation 1\nVariation 2";
  3533.    
  3534.  
  3535.         pfunc.caption = "Pixel Function";
  3536.         pfunc.default = "exp" ;
  3537.    
  3538.  
  3539.         lfunc1.caption = "Function 1";
  3540.         lfunc1.default = "ident" ;
  3541.    
  3542.  
  3543.         lfunc2.caption = "Function 2";
  3544.         lfunc2.default = "sinh" ;
  3545.    
  3546.     }
  3547. }
  3548.  
  3549.  
  3550. gp-bas01             {//Gedeon Peteri, January 2000
  3551. parameter complex pexp;
  3552. parameter complex exp;
  3553. parameter complex const;
  3554. parameter int test;
  3555. parameter real bailout;
  3556.  
  3557.     void init(void)
  3558.     {
  3559.         z = pfunc(pixel^pexp);
  3560.     }
  3561.     void loop(void)
  3562.     {
  3563.         z = lfunc1(lfunc2(z^exp)) + const;
  3564.     }
  3565.     bool bailout(void)
  3566.     {
  3567.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3568.     }
  3569.     void description(void)
  3570.     {
  3571.         this.title = "gp-bas01";
  3572.         this.maxiter = 500;
  3573.         this.periodicity = 0;
  3574.         this.magn = 0.75;
  3575.  
  3576.         pexp.caption = "Pixel Exponent";
  3577.         pexp.default = (1.0,0.0);
  3578.         pexp.hint = "Exponent of 'pixel' in init section";
  3579.    
  3580.  
  3581.         exp.caption = "Exponent";
  3582.         exp.default = (1.0,0.0);
  3583.         exp.hint = "Exponent of 'z' in loop section";
  3584.    
  3585.  
  3586.         const.caption = "Constant";
  3587.         const.default = (0.33,0.0);
  3588.    
  3589.  
  3590.         bailout.caption = "Bailout value";
  3591.         bailout.default = 4.0;
  3592.    
  3593.  
  3594.         test.caption = "Bailout test";
  3595.         test.default = 0;
  3596.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3597.    
  3598.  
  3599.         pfunc.caption = "Pixel Function";
  3600.         pfunc.default = "recip" ;
  3601.    
  3602.  
  3603.         lfunc1.caption = "Function 1";
  3604.         lfunc1.default = "ident" ;
  3605.         lfunc1.hint = "First of two nested functions";
  3606.    
  3607.  
  3608.         lfunc2.caption = "Function 2";
  3609.         lfunc2.default = "sqr" ;
  3610.         lfunc2.hint = "Second of two nested functions";
  3611.    
  3612.     }
  3613. }
  3614.  
  3615.  
  3616. gp-bas02             {//Gedeon Peteri, January 2000
  3617. parameter complex pexp;
  3618. parameter complex exp1;
  3619. parameter complex const1;
  3620. parameter complex exp2;
  3621. parameter complex const2;
  3622. parameter int test;
  3623. parameter real bailout;
  3624.  
  3625.     void init(void)
  3626.     {
  3627.         z = pfunc(pixel ^ pexp);
  3628.     }
  3629.     void loop(void)
  3630.     {
  3631.         z = lfunc((z^exp1 + const1)^exp2) + const2;
  3632.     }
  3633.     bool bailout(void)
  3634.     {
  3635.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3636.     }
  3637.     void description(void)
  3638.     {
  3639.         this.title = "gp-bas02";
  3640.         this.maxiter = 500;
  3641.         this.periodicity = 0;
  3642.  
  3643.         pexp.caption = "Pixel Exponent";
  3644.         pexp.default = (1.0,0.0);
  3645.         pexp.hint = "Exponent of 'pixel' in init section";
  3646.    
  3647.  
  3648.         exp1.caption = "First Exponent";
  3649.         exp1.default = (3.0,0.0);
  3650.         exp1.hint = "Exponent of 'z' in loop section";
  3651.    
  3652.  
  3653.         exp2.caption = "Second Exponent";
  3654.         exp2.default = (0.5,0.0);
  3655.         exp2.hint = "Exponent of 'z^@exp1+@const1' in loop section";
  3656.    
  3657.  
  3658.         const1.caption = "Constant 1";
  3659.         const1.default = (0.2,-0.5);
  3660.    
  3661.  
  3662.         const2.caption = "Constant 2";
  3663.         const2.default = (0.0,0.0);
  3664.    
  3665.  
  3666.         bailout.caption = "Bailout value";
  3667.         bailout.default = 64.0;
  3668.    
  3669.  
  3670.         test.caption = "Bailout test";
  3671.         test.default = 0;
  3672.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3673.    
  3674.  
  3675.         pfunc.caption = "Pixel Function";
  3676.         pfunc.default = "ident" ;
  3677.    
  3678.  
  3679.         lfunc.caption = "Function";
  3680.         lfunc.default = "ident" ;
  3681.         lfunc.hint = "Function in the loop section";
  3682.    
  3683.     }
  3684. }
  3685.  
  3686.  
  3687. gp-exp01  {//e^(|cosx|^(1/2)-|sinx|^(1/2))
  3688. complex Var_x;
  3689. parameter complex a;
  3690. complex Var_y;
  3691. parameter complex b;
  3692. parameter int var;
  3693. parameter complex exp;
  3694. parameter int test;
  3695. parameter real bailout;
  3696.  
  3697.     void init(void)
  3698.     {
  3699.         z=pfunc(pixel);
  3700.     }
  3701.     void loop(void)
  3702.     {
  3703.         Var_x = a*lfunc1(sqrt(abs(imag(z)/cabs(z))));
  3704.         Var_y = b*lfunc2(sqrt(abs(real(z)/cabs(z))));
  3705.         if  ((var == 0))
  3706.         {//Variation 1
  3707.             z = z^exp - lfunc3(exp(Var_y-Var_x));
  3708.         }
  3709.         else if  ((var == 1))
  3710.         {//Variation 2
  3711.             z = z^exp - lfunc3(exp(Var_x-Var_y));
  3712.         }
  3713.         else if  ((var == 2))
  3714.         {//Variation 3
  3715.             z = z^exp - lfunc3(exp(Var_x+Var_y));
  3716.         }
  3717.     }
  3718.     bool bailout(void)
  3719.     {
  3720.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3721.     }
  3722.     void description(void)
  3723.     {
  3724.         this.title="gp-exp01";
  3725.         this.maxiter = 250;
  3726.         this.periodicity = 0;
  3727.  
  3728.         a.caption="Parameter 1";
  3729.         a.default=(0.25,0.0);
  3730.    
  3731.  
  3732.         b.caption="Parameter 2";
  3733.         b.default=(0.25,0.0);
  3734.    
  3735.  
  3736.         exp.caption="Exponent";
  3737.         exp.default=(2.0,0.0);
  3738.    
  3739.  
  3740.         bailout.caption="Bailout value";
  3741.         bailout.default=100.0;
  3742.    
  3743.  
  3744.         test.caption = "Bailout test";
  3745.         test.default = 0;
  3746.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3747.    
  3748.  
  3749.         var.caption = "Variations";
  3750.         var.default = 0;
  3751.         var.enum = "Variation 1\nVariation 2\nVariation 3";
  3752.  
  3753.  
  3754.         lfunc1.caption="Function 1";
  3755.         lfunc1.default = "ident" ;
  3756.   
  3757.  
  3758.         lfunc2.caption="Function 2";
  3759.         lfunc2.default = "ident" ;
  3760.   
  3761.  
  3762.         lfunc3.caption="Function 3";
  3763.         lfunc3.default = "ident" ;
  3764.   
  3765.  
  3766.         pfunc.caption="Pixel Function";
  3767.         pfunc.default = "ident" ;
  3768.   
  3769.     }
  3770. }
  3771.  
  3772.  
  3773. comment
  3774. {
  3775. ;Formulas by Gedeon Peteri
  3776. ;gfpeul04/05/06 (1999) are identical to
  3777. ;gfpeul01/02/03 (1997) respectively,
  3778. ;but with a bailout test parameter added.
  3779.  
  3780.  
  3781. }
  3782.  
  3783. gfpeul01 {//Formula by Gedeon Peteri, 1997
  3784.           //Eulers's equation e^(ipi)+1=0
  3785. parameter complex p1;
  3786. parameter complex p2;
  3787. parameter real bailout;
  3788.  
  3789.     void init(void)
  3790.     {
  3791.         z=fn1(pixel);
  3792.     }
  3793.     void loop(void)
  3794.     {
  3795.         z=fn2(z^p1) + p2*fn3(exp(imag(z)*pi)+1);
  3796.     }
  3797.     bool bailout(void)
  3798.     {
  3799.         return(|z|<=bailout);
  3800.     }
  3801.     void description(void)
  3802.     {
  3803.         this.title="gfpeul01";
  3804.  
  3805.         p1.caption="Exponent";
  3806.         p1.default=(2.0,0.0);
  3807.    
  3808.  
  3809.         p2.caption="Parameter";
  3810.         p2.default=(0.2,0.0);
  3811.    
  3812.  
  3813.         bailout.caption="Bailout";
  3814.         bailout.default=4.0;
  3815.    
  3816.  
  3817.         fn1.caption="Function 1";
  3818.         fn1.default = "ident" ;
  3819.   
  3820.  
  3821.         fn2.caption="Function 2";
  3822.         fn2.default = "ident" ;
  3823.   
  3824.  
  3825.         fn3.caption="Function 3";
  3826.         fn3.default = "ident" ;
  3827.   
  3828.     }
  3829. }
  3830.  
  3831.  
  3832. gfpeul02 {//Formula by Gedeon Peteri, 1997
  3833.           //Eulers's equation e^(ipi)+1=0
  3834. parameter complex p1;
  3835. parameter complex p2;
  3836. parameter real bailout;
  3837.  
  3838.     void init(void)
  3839.     {
  3840.         z=fn1(pixel);
  3841.     }
  3842.     void loop(void)
  3843.     {
  3844.         z=fn2(z^p1) + p2*fn3(exp(imag(z)*pi)-1);
  3845.     }
  3846.     bool bailout(void)
  3847.     {
  3848.         return(|z|<=bailout);
  3849.     }
  3850.     void description(void)
  3851.     {
  3852.         this.title="gfpeul02";
  3853.  
  3854.         p1.caption="Exponent";
  3855.         p1.default=(3.0,0.0);
  3856.    
  3857.  
  3858.         p2.caption="Parameter";
  3859.         p2.default=(1.0,0.35);
  3860.    
  3861.  
  3862.         bailout.caption="Bailout";
  3863.         bailout.default=4.0;
  3864.    
  3865.  
  3866.         fn1.caption="Function 1";
  3867.         fn1.default = "ident" ;
  3868.   
  3869.  
  3870.         fn2.caption="Function 2";
  3871.         fn2.default = "ident" ;
  3872.   
  3873.  
  3874.         fn3.caption="Function 3";
  3875.         fn3.default = "ident" ;
  3876.   
  3877.     }
  3878. }
  3879.  
  3880.  
  3881. gfpeul03 {//Formula by Gedeon Peteri, 1997
  3882.           //Eulers's equation e^(ipi)+1=0
  3883. complex c;
  3884. parameter complex p1;
  3885. parameter complex p2;
  3886. parameter real bailout;
  3887.  
  3888.     void init(void)
  3889.     {
  3890.         z=pixel;
  3891.         c=pixel;
  3892.     }
  3893.     void loop(void)
  3894.     {
  3895.         z=fn1(z^p1) + p2*fn2(exp(imag(c)*pi)+1);
  3896.     }
  3897.     bool bailout(void)
  3898.     {
  3899.         return(|z|<=bailout);
  3900.     }
  3901.     void description(void)
  3902.     {
  3903.         this.title="gfpeul03";
  3904.  
  3905.         p1.caption="Exponent";
  3906.         p1.default=(2.0,0.0);
  3907.    
  3908.  
  3909.         p2.caption="Parameter";
  3910.         p2.default=(0.25,0.0);
  3911.    
  3912.  
  3913.         bailout.caption="Bailout";
  3914.         bailout.default=4.0;
  3915.    
  3916.  
  3917.         fn1.caption="Function 1";
  3918.         fn1.default = "ident" ;
  3919.   
  3920.  
  3921.         fn2.caption="Function 2";
  3922.         fn2.default = "ident" ;
  3923.   
  3924.     }
  3925. }
  3926.  
  3927.  
  3928. gfpeul04   {//Formula by Gedeon Peteri, 1999
  3929.             //Eulers's equation e^(ipi)+1=0
  3930. parameter complex p1;
  3931. parameter complex p2;
  3932. parameter int test;
  3933. parameter real bailout;
  3934.  
  3935.     void init(void)
  3936.     {
  3937.         z=fn1(pixel);
  3938.     }
  3939.     void loop(void)
  3940.     {
  3941.         z=fn2(z^p1) + p2*fn3(exp(imag(z)*pi)+1);
  3942.     }
  3943.     bool bailout(void)
  3944.     {
  3945.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  3946.     }
  3947.     void description(void)
  3948.     {
  3949.         this.title="gfpeul04";
  3950.  
  3951.         p1.caption="Exponent";
  3952.         p1.default=(2.0,0.0);
  3953.    
  3954.  
  3955.         p2.caption="Parameter";
  3956.         p2.default=(0.2,0.0);
  3957.    
  3958.  
  3959.         test.caption = "Bailout Test";
  3960.         test.default = 0;
  3961.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  3962.    
  3963.  
  3964.         bailout.caption = "Bailout value";
  3965.         bailout.default = 4.0;
  3966.    
  3967.  
  3968.         fn1.caption="Function 1";
  3969.         fn1.default = "ident" ;
  3970.   
  3971.  
  3972.         fn2.caption="Function 2";
  3973.         fn2.default = "ident" ;
  3974.   
  3975.  
  3976.         fn3.caption="Function 3";
  3977.         fn3.default = "ident" ;
  3978.   
  3979.     }
  3980. }
  3981.  
  3982.  
  3983. gfpeul05   {//Formula by Gedeon Peteri, 1999
  3984.             //Eulers's equation e^(ipi)+1=0
  3985. parameter complex p1;
  3986. parameter complex p2;
  3987. parameter int test;
  3988. parameter real bailout;
  3989.  
  3990.     void init(void)
  3991.     {
  3992.         z=fn1(pixel);
  3993.     }
  3994.     void loop(void)
  3995.     {
  3996.         z=fn2(z^p1) + p2*fn3(exp(imag(z)*pi)-1);
  3997.     }
  3998.     bool bailout(void)
  3999.     {
  4000.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  4001.     }
  4002.     void description(void)
  4003.     {
  4004.         this.title="gfpeul05";
  4005.  
  4006.         p1.caption="Exponent";
  4007.         p1.default=(3.0,0.0);
  4008.    
  4009.  
  4010.         p2.caption="Parameter";
  4011.         p2.default=(1.0,0.35);
  4012.    
  4013.  
  4014.         test.caption = "Bailout Test";
  4015.         test.default = 0;
  4016.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  4017.    
  4018.  
  4019.         bailout.caption = "Bailout value";
  4020.         bailout.default = 4.0;
  4021.    
  4022.  
  4023.         fn1.caption="Function 1";
  4024.         fn1.default = "ident" ;
  4025.   
  4026.  
  4027.         fn2.caption="Function 2";
  4028.         fn2.default = "ident" ;
  4029.   
  4030.  
  4031.         fn3.caption="Function 3";
  4032.         fn3.default = "ident" ;
  4033.   
  4034.     }
  4035. }
  4036.  
  4037.  
  4038. gfpeul06   {//Formula by Gedeon Peteri, 1999
  4039.             //Eulers's equation e^(ipi)+1=0
  4040. complex c;
  4041. parameter complex p1;
  4042. parameter complex p2;
  4043. parameter int test;
  4044. parameter real bailout;
  4045.  
  4046.     void init(void)
  4047.     {
  4048.         z=pixel;
  4049.         c=pixel;
  4050.     }
  4051.     void loop(void)
  4052.     {
  4053.         z=fn1(z^p1) + p2*fn2(exp(imag(c)*pi)+1);
  4054.     }
  4055.     bool bailout(void)
  4056.     {
  4057.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  4058.     }
  4059.     void description(void)
  4060.     {
  4061.         this.title="gfpeul06";
  4062.  
  4063.         p1.caption="Exponent";
  4064.         p1.default=(2.0,0.0);
  4065.    
  4066.  
  4067.         p2.caption="Parameter";
  4068.         p2.default=(0.25,0.0);
  4069.    
  4070.  
  4071.         test.caption = "Bailout Test";
  4072.         test.default = 0;
  4073.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  4074.    
  4075.  
  4076.         bailout.caption = "Bailout value";
  4077.         bailout.default = 4.0;
  4078.    
  4079.  
  4080.         fn1.caption="Function 1";
  4081.         fn1.default = "ident" ;
  4082.   
  4083.  
  4084.         fn2.caption="Function 2";
  4085.         fn2.default = "ident" ;
  4086.   
  4087.     }
  4088. }
  4089.  
  4090.  
  4091. comment
  4092. {
  4093. ;Source: chebymod.ufm:
  4094.  
  4095. }
  4096.  
  4097. comment {;This file contains selected formulas from Morgan L. Owens' Chebyshev
  4098. ;collection, translated from the original Fractint to Ultra Fractal format.
  4099. ;Modifications are limited to:
  4100. ;(1) generalization of hard coded bailouts and functions;
  4101. ;(2) addition of user definable functions;
  4102. ;(3) defaults have been set to produce the results of the original formula.
  4103. ;This file was prepared by Gedeon Peteri, 1999.}
  4104.  
  4105.  
  4106. gpm-al03-20  {//chby20 / Alpha03-20 formula by Morgan L. Owens
  4107.              //Translated from .frm to .ufm
  4108.              //and slightly modified by Gedeon Peteri, November 1999
  4109. complex t;
  4110. parameter complex p1;
  4111. complex Var_x;
  4112. complex Var_y;
  4113. complex x2;
  4114. complex y2;
  4115. parameter real bailout;
  4116.  
  4117.     void init(void)
  4118.     {
  4119.         z=fn4(pixel);
  4120.         t=p1;
  4121.     }
  4122.     void loop(void)
  4123.     {
  4124.         Var_x=real(z);
  4125.         Var_y=imag(z);
  4126.         x2=Var_x*Var_x;
  4127.         y2=Var_y*Var_y;
  4128.         Var_y=Var_y+t*fn1((((Var_x-3)*Var_x+6)*Var_x-6)/(exp(Var_x)*x2*x2));
  4129.         Var_x=Var_x-t*fn2((((Var_y-3)*Var_y+6)*Var_y-6)/(exp(Var_y)*y2*y2));
  4130.         z=Var_x+fn3(Var_y);
  4131.     }
  4132.     bool bailout(void)
  4133.     {
  4134.         return(|z|<=bailout);
  4135.     }
  4136.     void description(void)
  4137.     {
  4138.         this.title="gpm-al03-20";
  4139.  
  4140.         p1.caption="Parameter";
  4141.         p1.default=(0.1,0.0);
  4142.    
  4143.  
  4144.         bailout.caption="Bailout";
  4145.         bailout.default=4.0;
  4146.    
  4147.  
  4148.         fn1.caption="Function 1";
  4149.         fn1.default = "sin" ;
  4150.   
  4151.  
  4152.         fn2.caption="Function 2";
  4153.         fn2.default = "sin" ;
  4154.   
  4155.  
  4156.         fn3.caption="Function 3";
  4157.         fn3.default = "flip" ;
  4158.   
  4159.  
  4160.         fn4.caption="Function 4";
  4161.         fn4.default = "ident" ;
  4162.   
  4163.     }
  4164. }
  4165.  
  4166.  
  4167. gpm-c02-15  {//chby15 / c02-15 formula by Morgan L. Owens
  4168.              //Translated from .frm to .ufm
  4169.              //and slightly modified by Gedeon Peteri, March 1999
  4170. complex r;
  4171. parameter complex p1;
  4172. complex f;
  4173. complex fd;
  4174. complex oz;
  4175. parameter real bailout;
  4176.  
  4177.     void init(void)
  4178.     {
  4179.         z=fn3(pixel);
  4180.         r=p1;
  4181.     }
  4182.     void loop(void)
  4183.     {
  4184.         f=fn1(z*z-2);
  4185.         fd=fn2(2*z);
  4186.         oz=z;
  4187.         z=z-r*f/fd;
  4188.     }
  4189.     bool bailout(void)
  4190.     {
  4191.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  4192.     }
  4193.     void description(void)
  4194.     {
  4195.         this.title="gpm-c02-15";
  4196.  
  4197.         p1.caption="Parameter";
  4198.         p1.default=(2.0,1.0);
  4199.    
  4200.  
  4201.         bailout.caption="Bailout";
  4202.         bailout.default=1.0;
  4203.    
  4204.  
  4205.         fn1.caption="Function 1";
  4206.         fn1.default = "ident" ;
  4207.   
  4208.  
  4209.         fn2.caption="Function 2";
  4210.         fn2.default = "ident" ;
  4211.   
  4212.  
  4213.         fn3.caption="Function 3";
  4214.         fn3.default = "ident" ;
  4215.   
  4216.     }
  4217. }
  4218.  
  4219.  
  4220. gpm-c03-01  {//chby1 / c03-01 formula by Morgan L. Owens
  4221.              //Translated from .frm to .ufm
  4222.              //and slightly modified by Gedeon Peteri, March 1999
  4223. complex t;
  4224. parameter complex p1;
  4225. complex Var_x;
  4226. complex Var_y;
  4227. complex tx;
  4228. complex ty;
  4229. parameter real bailout;
  4230.  
  4231.     void init(void)
  4232.     {
  4233.         z=fn3(pixel);
  4234.         t=p1;
  4235.     }
  4236.     void loop(void)
  4237.     {
  4238.         Var_x=real(z);
  4239.         Var_y=imag(z);
  4240.         tx=fn1(Var_x*(Var_x*Var_x-3));
  4241.         ty=fn2(Var_y*(Var_y*Var_y-3));
  4242.         Var_x=Var_x-t*ty;
  4243.         Var_y=Var_y+t*tx;
  4244.         z=Var_x+fn4(Var_y);
  4245.     }
  4246.     bool bailout(void)
  4247.     {
  4248.         return(|z|<=bailout);
  4249.     }
  4250.     void description(void)
  4251.     {
  4252.         this.title="gpm-c03-01";
  4253.  
  4254.         p1.caption="Parameter";
  4255.         p1.default=(0.25,0.0);
  4256.    
  4257.  
  4258.         bailout.caption="Bailout";
  4259.         bailout.default=4.0;
  4260.    
  4261.  
  4262.         fn1.caption="Function 1";
  4263.         fn1.default = "ident" ;
  4264.   
  4265.  
  4266.         fn2.caption="Function 2";
  4267.         fn2.default = "ident" ;
  4268.   
  4269.  
  4270.         fn3.caption="Function 3";
  4271.         fn3.default = "ident" ;
  4272.   
  4273.  
  4274.         fn4.caption="Function 4";
  4275.         fn4.default = "flip" ;
  4276.   
  4277.     }
  4278. }
  4279.  
  4280.  
  4281. gpm-c04-01  {//chby1 / c04-01 formula by Morgan L. Owens
  4282.              //Translated from .frm to .ufm
  4283.              //and slightly modified by Gedeon Peteri, April 1999
  4284. complex t;
  4285. parameter complex p1;
  4286. complex Var_x;
  4287. complex Var_y;
  4288. complex xx;
  4289. complex yy;
  4290. complex tx;
  4291. parameter complex p2;
  4292. complex ty;
  4293. parameter complex p3;
  4294. parameter real bailout;
  4295.  
  4296.     void init(void)
  4297.     {
  4298.         z=fn3(pixel);
  4299.         t=p1;
  4300.     }
  4301.     void loop(void)
  4302.     {
  4303.         Var_x=real(z);
  4304.         Var_y=imag(z);
  4305.         xx=Var_x*Var_x;
  4306.         yy=Var_y*Var_y;
  4307.         tx=p2*fn1(xx*(xx-4)+2);
  4308.         ty=p3*fn2(yy*(yy-4)+2);
  4309.         Var_x=Var_x-t*ty;
  4310.         Var_y=Var_y+t*tx;
  4311.         z=Var_x+fn4(Var_y);
  4312.     }
  4313.     bool bailout(void)
  4314.     {
  4315.         return(|z|<=bailout);
  4316.     }
  4317.     void description(void)
  4318.     {
  4319.         this.title="gpm-c04-01";
  4320.  
  4321.         p1.caption="Parameter 1";
  4322.         p1.default=(0.25,0.0);
  4323.    
  4324.  
  4325.         p2.caption="Parameter 2";
  4326.         p2.default=(1.0,0.0);
  4327.    
  4328.  
  4329.         p3.caption="Parameter 3";
  4330.         p3.default=(1.0,0.0);
  4331.    
  4332.  
  4333.         bailout.caption="Bailout";
  4334.         bailout.default=4.0;
  4335.    
  4336.  
  4337.         fn1.caption="Function 1";
  4338.         fn1.default = "ident" ;
  4339.   
  4340.  
  4341.         fn2.caption="Function 2";
  4342.         fn2.default = "ident" ;
  4343.   
  4344.  
  4345.         fn3.caption="Function 3";
  4346.         fn3.default = "ident" ;
  4347.   
  4348.  
  4349.         fn4.caption="Function 4";
  4350.         fn4.default = "flip" ;
  4351.   
  4352.     }
  4353. }
  4354.  
  4355.  
  4356. gpm-c05-01  {//chby1 / c05-01 formula by Morgan L. Owens
  4357.              //Translated from .frm to .ufm
  4358.              //and slightly modified by Gedeon Peteri, March 1999
  4359. complex t;
  4360. parameter complex p1;
  4361. complex Var_x;
  4362. complex Var_y;
  4363. complex xx;
  4364. complex yy;
  4365. complex tx;
  4366. complex ty;
  4367. parameter real bailout;
  4368.  
  4369.     void init(void)
  4370.     {
  4371.         z=fn3(pixel);
  4372.         t=p1;
  4373.     }
  4374.     void loop(void)
  4375.     {
  4376.         Var_x=real(z);
  4377.         Var_y=imag(z);
  4378.         xx=Var_x*Var_x;
  4379.         yy=Var_y*Var_y;
  4380.         tx=fn1(Var_x*(xx*(xx-5)+3));
  4381.         ty=fn2(Var_y*(yy*(yy-5)+3));
  4382.         Var_x=Var_x-t*ty;
  4383.         Var_y=Var_y+t*tx;
  4384.         z=Var_x+fn4(Var_y);
  4385.     }
  4386.     bool bailout(void)
  4387.     {
  4388.         return(|z|<=bailout);
  4389.     }
  4390.     void description(void)
  4391.     {
  4392.         this.title="gpm-c05-01";
  4393.  
  4394.         p1.caption="Parameter";
  4395.         p1.default=(0.5,0.0);
  4396.    
  4397.  
  4398.         bailout.caption="Bailout";
  4399.         bailout.default=4.0;
  4400.    
  4401.  
  4402.         fn1.caption="Function 1";
  4403.         fn1.default = "ident" ;
  4404.   
  4405.  
  4406.         fn2.caption="Function 2";
  4407.         fn2.default = "ident" ;
  4408.   
  4409.  
  4410.         fn3.caption="Function 3";
  4411.         fn3.default = "ident" ;
  4412.   
  4413.  
  4414.         fn4.caption="Function 4";
  4415.         fn4.default = "flip" ;
  4416.   
  4417.     }
  4418. }
  4419.  
  4420.  
  4421. gpm-c06-05  {//chby5 / c06-05 formula by Morgan L. Owens
  4422.              //Translated from .frm to .ufm
  4423.              //and slightly modified by Gedeon Peteri, April 1999
  4424. complex r;
  4425. parameter complex p1;
  4426. complex zz;
  4427. complex f;
  4428. parameter complex p2;
  4429. complex fd;
  4430. parameter complex p3;
  4431. complex oz;
  4432. parameter real bailout;
  4433.  
  4434.     void init(void)
  4435.     {
  4436.         z=fn4(pixel);
  4437.         r=p1;
  4438.     }
  4439.     void loop(void)
  4440.     {
  4441.         zz=z*z;
  4442.         f=p2*fn1(zz*(zz*(zz-6)+7)-2);
  4443.         fd=p3*fn2(2*z*(3*zz*(zz-4)+7));
  4444.         oz=z;
  4445.         z=z-fn3(r*f/fd);
  4446.     }
  4447.     bool bailout(void)
  4448.     {
  4449.         return(bailout<=|z-oz|);
  4450.     }
  4451.     void description(void)
  4452.     {
  4453.         this.title="gpm-c06-05";
  4454.  
  4455.         p1.caption="Parameter 1";
  4456.         p1.default=(1.0,1.0);
  4457.    
  4458.  
  4459.         p2.caption="Parameter 2";
  4460.         p2.default=(2.5,0.0);
  4461.    
  4462.  
  4463.         p3.caption="Parameter 3";
  4464.         p3.default=(1.0,0.0);
  4465.    
  4466.  
  4467.         bailout.caption="Bailout";
  4468.         bailout.default=1.0;
  4469.    
  4470.  
  4471.         fn1.caption="Function 1";
  4472.         fn1.default = "ident" ;
  4473.   
  4474.  
  4475.         fn2.caption="Function 2";
  4476.         fn2.default = "ident" ;
  4477.   
  4478.  
  4479.         fn3.caption="Function 3";
  4480.         fn3.default = "ident" ;
  4481.   
  4482.  
  4483.         fn4.caption="Function 4";
  4484.         fn4.default = "ident" ;
  4485.   
  4486.     }
  4487. }
  4488.  
  4489.  
  4490. gpm-c07-09  {//chby9 / c07-09 formula by Morgan L. Owens
  4491.              //Translated from .frm to .ufm
  4492.              //and slightly modified by Gedeon Peteri, March 1999
  4493. complex t;
  4494. parameter complex p1;
  4495. complex a;
  4496. parameter complex p2;
  4497. complex b;
  4498. parameter complex p3;
  4499. complex Var_x;
  4500. complex Var_y;
  4501. complex xx;
  4502. complex yy;
  4503. complex tx;
  4504. complex ty;
  4505. parameter real bailout;
  4506.  
  4507.     void init(void)
  4508.     {
  4509.         z=fn4(pixel);
  4510.         t=p1;
  4511.         a=p2;
  4512.         b=p3;
  4513.     }
  4514.     void loop(void)
  4515.     {
  4516.         Var_x=real(z);
  4517.         Var_y=imag(z);
  4518.         xx=Var_x*Var_x;
  4519.         yy=Var_y*Var_y;
  4520.         tx=a*fn1(Var_x*(xx*(xx*(xx-7)+12)-5));
  4521.         ty=b*fn2(Var_y*(yy*(yy*(yy-7)+12)-5));
  4522.         Var_x=Var_x-t*ty;
  4523.         Var_y=Var_y+t*tx;
  4524.         z=fn3(Var_x+flip(Var_y));
  4525.     }
  4526.     bool bailout(void)
  4527.     {
  4528.         return(|z|<=bailout);
  4529.     }
  4530.     void description(void)
  4531.     {
  4532.         this.title="gpm-c07-09";
  4533.  
  4534.         p1.caption="Parameter 1";
  4535.         p1.default=(0.5,0.0);
  4536.    
  4537.  
  4538.         p2.caption="Parameter 2";
  4539.         p2.default=(1.0,0.0);
  4540.    
  4541.  
  4542.         p3.caption="Parameter 3";
  4543.         p3.default=(1.0,0.0);
  4544.    
  4545.  
  4546.         bailout.caption="Bailout";
  4547.         bailout.default=4.0;
  4548.    
  4549.  
  4550.         fn1.caption="Function 1";
  4551.         fn1.default = "ident" ;
  4552.   
  4553.  
  4554.         fn2.caption="Function 2";
  4555.         fn2.default = "ident" ;
  4556.   
  4557.  
  4558.         fn3.caption="Function 3";
  4559.         fn3.default = "ident" ;
  4560.   
  4561.  
  4562.         fn4.caption="Function 4";
  4563.         fn4.default = "ident" ;
  4564.   
  4565.     }
  4566. }
  4567.  
  4568.  
  4569. gpm-c07-15  {//chby15 / c07-15 formula by Morgan L. Owens
  4570.              //Translated from .frm to .ufm
  4571.              //and slightly modified by Gedeon Peteri, March 1999
  4572. complex r;
  4573. parameter complex p1;
  4574. complex zz;
  4575. complex f;
  4576. complex fd;
  4577. complex oz;
  4578. parameter real bailout;
  4579.  
  4580.     void init(void)
  4581.     {
  4582.         z=fn4(pixel);
  4583.         r=p1;
  4584.     }
  4585.     void loop(void)
  4586.     {
  4587.         zz=z*z;
  4588.         f=fn1(z*(zz*(zz*(zz-7)+12)-5));
  4589.         fd=fn2(zz*(7*zz*(zz-5)+36)-5);
  4590.         oz=z;
  4591.         z=z-fn3(r*f/fd);
  4592.     }
  4593.     bool bailout(void)
  4594.     {
  4595.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  4596.     }
  4597.     void description(void)
  4598.     {
  4599.         this.title="gpm-c07-15";
  4600.  
  4601.         p1.caption="Parameter";
  4602.         p1.default=(1.0,0.0);
  4603.    
  4604.  
  4605.         bailout.caption="Bailout";
  4606.         bailout.default=1.0;
  4607.    
  4608.  
  4609.         fn1.caption="Function 1";
  4610.         fn1.default = "ident" ;
  4611.   
  4612.  
  4613.         fn2.caption="Function 2";
  4614.         fn2.default = "ident" ;
  4615.   
  4616.  
  4617.         fn3.caption="Function 3";
  4618.         fn3.default = "ident" ;
  4619.   
  4620.  
  4621.         fn4.caption="Function 4";
  4622.         fn4.default = "ident" ;
  4623.   
  4624.     }
  4625. }
  4626.  
  4627.  
  4628. gpm-c10-12  {//chby12 / c10-12 formula by Morgan L. Owens
  4629.              //Translated from .frm to .ufm
  4630.              //and slightly modified by Gedeon Peteri, November 1999
  4631. parameter complex p1;
  4632. complex const;
  4633. complex zz;
  4634. parameter complex p2;
  4635. parameter real bailout;
  4636.  
  4637.     void init(void)
  4638.     {
  4639.         z=p1;
  4640.         const=pixel;
  4641.     }
  4642.     void loop(void)
  4643.     {
  4644.         zz=z*z;
  4645.         z=p2*fn1((zz*(zz*(zz*(zz*(zz-10)+33)-42)+19)-2))*const;
  4646.     }
  4647.     bool bailout(void)
  4648.     {
  4649.         return(|z|<=bailout);
  4650.     }
  4651.     void description(void)
  4652.     {
  4653.         this.title="gpm-c10-12";
  4654.  
  4655.         p1.caption="Parameter 1";
  4656.         p1.default=(1.0,0.0);
  4657.    
  4658.  
  4659.         p2.caption="Parameter 2";
  4660.         p2.default=(0.5,0.0);
  4661.    
  4662.  
  4663.         bailout.caption="Bailout";
  4664.         bailout.default=100.0;
  4665.    
  4666.  
  4667.         fn1.caption="Function 1";
  4668.         fn1.default = "ident" ;
  4669.   
  4670.     }
  4671. }
  4672.  
  4673.  
  4674. gpm-c10-13  {//chby13 / c10-13 formula by Morgan L. Owens
  4675.              //Translated from .frm to .ufm
  4676.              //and slightly modified by Gedeon Peteri, March 1999
  4677. complex r;
  4678. parameter complex p1;
  4679. complex zz;
  4680. complex f;
  4681. complex fd;
  4682. complex fdd;
  4683. complex oz;
  4684. parameter real bailout;
  4685.  
  4686.     void init(void)
  4687.     {
  4688.         z=fn4(pixel);
  4689.         r=p1;
  4690.     }
  4691.     void loop(void)
  4692.     {
  4693.         zz=z*z;
  4694.         f=fn1(zz*(zz*(zz*(zz*(zz-10)+33)-42)+19)-2);
  4695.         fd=fn2(2*z*(zz*(zz*(5*zz*(zz-8)+99)-84)+19));
  4696.         fdd=fn3(2*zz*(5*zz*(zz*(9*zz-56)+99)-252)+38);
  4697.         oz=z;
  4698.         z=z-r*f/(fd-fdd*f/(fd+fd));
  4699.     }
  4700.     bool bailout(void)
  4701.     {
  4702.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  4703.     }
  4704.     void description(void)
  4705.     {
  4706.         this.title="gpm-c10-13";
  4707.  
  4708.         p1.caption="Parameter";
  4709.         p1.default=(3.0,1.0);
  4710.    
  4711.  
  4712.         bailout.caption="Bailout";
  4713.         bailout.default=1.0;
  4714.    
  4715.  
  4716.         fn1.caption="Function 1";
  4717.         fn1.default = "ident" ;
  4718.   
  4719.  
  4720.         fn2.caption="Function 2";
  4721.         fn2.default = "ident" ;
  4722.   
  4723.  
  4724.         fn3.caption="Function 3";
  4725.         fn3.default = "ident" ;
  4726.   
  4727.  
  4728.         fn4.caption="Function 4";
  4729.         fn4.default = "ident" ;
  4730.   
  4731.     }
  4732. }
  4733.  
  4734.  
  4735. gpm-c10-15  {//chby15 / c10-15 formula by Morgan L. Owens
  4736.              //Translated from .frm to .ufm
  4737.              //and slightly modified by Gedeon Peteri, November 1999
  4738. complex r;
  4739. parameter complex p1;
  4740. complex zz;
  4741. complex f;
  4742. parameter complex p2;
  4743. complex fd;
  4744. parameter complex p3;
  4745. complex oz;
  4746. parameter real bailout;
  4747.  
  4748.     void init(void)
  4749.     {
  4750.         z=fn4(pixel);
  4751.         r=p1;
  4752.     }
  4753.     void loop(void)
  4754.     {
  4755.         zz=z*z;
  4756.         f=p2*fn1(zz*(zz*(zz*(zz*(zz-10)+33)-42)+19)-2);
  4757.         fd=p3*fn2(2*z*(zz*(zz*(5*zz*(zz-8)+99)-84)+19));
  4758.         oz=z;
  4759.         z=fn3(z-r*f/fd);
  4760.     }
  4761.     bool bailout(void)
  4762.     {
  4763.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  4764.     }
  4765.     void description(void)
  4766.     {
  4767.         this.title="gpm-c10-15";
  4768.  
  4769.         p1.caption="Parameter 1";
  4770.         p1.default=(3.0,3.0);
  4771.    
  4772.  
  4773.         p2.caption="Parameter 2";
  4774.         p2.default=(2.0,0.0);
  4775.    
  4776.  
  4777.         p3.caption="Parameter 3";
  4778.         p3.default=(1.0,0.0);
  4779.    
  4780.  
  4781.         bailout.caption="Bailout";
  4782.         bailout.default=1.0;
  4783.    
  4784.  
  4785.         fn1.caption="Function 1";
  4786.         fn1.default = "ident" ;
  4787.   
  4788.  
  4789.         fn2.caption="Function 2";
  4790.         fn2.default = "ident" ;
  4791.   
  4792.  
  4793.         fn3.caption="Function 3";
  4794.         fn3.default = "ident" ;
  4795.   
  4796.  
  4797.         fn4.caption="Function 4";
  4798.         fn4.default = "ident" ;
  4799.   
  4800.     }
  4801. }
  4802.  
  4803.  
  4804. gpm-ca04-21 {//chby21 / ca04-21 formula by Morgan L. Owens
  4805.              //Translated from .frm to .ufm
  4806.              //and slightly modified by Gedeon Peteri, November 1999
  4807. complex a;
  4808. parameter complex p1;
  4809. complex b;
  4810. complex c;
  4811. complex d;
  4812. complex t;
  4813. parameter complex p2;
  4814. complex Var_x;
  4815. complex Var_y;
  4816. complex xx;
  4817. complex yy;
  4818. parameter real bailout;
  4819.  
  4820.     void init(void)
  4821.     {
  4822.         a=p1;
  4823.         b=a*(a+1)/2;
  4824.         c=4*(a+2);
  4825.         d=(a+3)/3;
  4826.         t=real(p2);
  4827.         z=pixel;
  4828.     }
  4829.     void loop(void)
  4830.     {
  4831.         Var_x=real(z);
  4832.         Var_y=imag(z);
  4833.         xx=Var_x*Var_x;
  4834.         Var_y=Var_y+t*(fn1(b*(c*xx*(d*xx-1)+1)));
  4835.         yy=Var_y*Var_y;
  4836.         Var_x=Var_x-t*(fn2(b*(c*yy*(d*yy-1)+1)));
  4837.         z=Var_x+fn3(Var_y);
  4838.     }
  4839.     bool bailout(void)
  4840.     {
  4841.         return(|z|<=bailout);
  4842.     }
  4843.     void description(void)
  4844.     {
  4845.         this.title="gpm-ca04-21";
  4846.  
  4847.         p1.caption="Parameter 1";
  4848.         p1.default=(0.4,0.0);
  4849.    
  4850.  
  4851.         p2.caption="Parameter 2";
  4852.         p2.default=(1.0,0.0);
  4853.    
  4854.  
  4855.         bailout.caption="Bailout";
  4856.         bailout.default=4.0;
  4857.    
  4858.  
  4859.         fn1.caption="Function 1";
  4860.         fn1.default = "ident" ;
  4861.   
  4862.  
  4863.         fn2.caption="Function 2";
  4864.         fn2.default = "ident" ;
  4865.   
  4866.  
  4867.         fn3.caption="Function 3";
  4868.         fn3.default = "flip" ;
  4869.   
  4870.     }
  4871. }
  4872.  
  4873.  
  4874. gpm-ca06-01 {//chby1 / ca06-01 formula by Morgan L. Owens
  4875.              //Translated from .frm to .ufm
  4876.              //and slightly modified by Gedeon Peteri, September 2000
  4877. complex t;
  4878. parameter complex p1;
  4879. complex a;
  4880. parameter complex p2;
  4881. complex b;
  4882. complex c;
  4883. complex d;
  4884. complex k;
  4885. complex Var_x;
  4886. complex Var_y;
  4887. complex xx;
  4888. complex yy;
  4889. complex tx;
  4890. complex ty;
  4891. parameter int test;
  4892. parameter real bailout;
  4893.  
  4894.     void init(void)
  4895.     {
  4896.         z=fn4(pixel);
  4897.         t=p1;
  4898.         a=p2;
  4899.         b=a*(a*(a+3)+2)/6;
  4900.         c=a+3;
  4901.         d=4*(a+4);
  4902.         k=(a+a+10)/15;
  4903.     }
  4904.     void loop(void)
  4905.     {
  4906.         Var_x=real(z);
  4907.         Var_y=imag(z);
  4908.         xx=Var_x*Var_x;
  4909.         yy=Var_y*Var_y;
  4910.         tx=fn1(b*(c*xx*(d*xx*(k*xx-1)+3)-1));
  4911.         ty=fn2(b*(c*yy*(d*yy*(k*yy-1)+3)-1));
  4912.         Var_x=Var_x-t*ty;
  4913.         Var_y=Var_y+t*tx;
  4914.         z=Var_x+fn3(Var_y);
  4915.     }
  4916.     bool bailout(void)
  4917.     {
  4918.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  4919.     }
  4920.     void description(void)
  4921.     {
  4922.         this.title="gpm-ca06-01";
  4923.  
  4924.         p1.caption="Parameter 1";
  4925.         p1.default=(0.5,0.0);
  4926.    
  4927.  
  4928.         p2.caption="Parameter 2";
  4929.         p2.default=(0.5,0.0);
  4930.    
  4931.  
  4932.         test.caption = "Bailout Test";
  4933.         test.default = 0;
  4934.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  4935.    
  4936.  
  4937.         bailout.caption = "Bailout value";
  4938.         bailout.default = 4.0;
  4939.    
  4940.  
  4941.         fn1.caption="Function 1";
  4942.         fn1.default = "ident" ;
  4943.   
  4944.  
  4945.         fn2.caption="Function 2";
  4946.         fn2.default = "ident" ;
  4947.   
  4948.  
  4949.         fn3.caption="Function 3";
  4950.         fn3.default = "flip" ;
  4951.   
  4952.  
  4953.         fn4.caption="Pixel Function";
  4954.         fn4.default = "ident" ;
  4955.   
  4956.     }
  4957. }
  4958.  
  4959.  
  4960. gpm-ca06-03 {//chby3 / ca06-03 formula by Morgan L. Owens
  4961.              //Translated from .frm to .ufm
  4962.              //and slightly modified by Gedeon Peteri, April 1999
  4963. complex const;
  4964. parameter complex p1;
  4965. complex a;
  4966. parameter complex p2;
  4967. complex b;
  4968. complex c;
  4969. complex d;
  4970. complex k;
  4971. complex zz;
  4972. parameter complex p3;
  4973. parameter real bailout;
  4974.  
  4975.     void init(void)
  4976.     {
  4977.         z=fn2(pixel);
  4978.         const=p1;
  4979.         a=p2;
  4980.         b=a*(a*(a+3)+2)/6;
  4981.         c=a+3;
  4982.         d=4*(a+4);
  4983.         k=(a+a+10)/15;
  4984.     }
  4985.     void loop(void)
  4986.     {
  4987.         zz=z*z;
  4988.         z=p3*fn1(b*(c*zz*(d*zz*(k*zz-1)+3)-1)+const);
  4989.     }
  4990.     bool bailout(void)
  4991.     {
  4992.         return(|z|<=bailout);
  4993.     }
  4994.     void description(void)
  4995.     {
  4996.         this.title="gpm-ca06-03";
  4997.  
  4998.         p1.caption="Parameter 1";
  4999.         p1.default=(0.7,0.0);
  5000.    
  5001.  
  5002.         p2.caption="Parameter 2";
  5003.         p2.default=(0.7,0.0);
  5004.    
  5005.  
  5006.         p3.caption="Parameter 3";
  5007.         p3.default=(1.0,0.0);
  5008.    
  5009.  
  5010.         bailout.caption="Bailout";
  5011.         bailout.default=100.0;
  5012.    
  5013.  
  5014.         fn1.caption="Function 1";
  5015.         fn1.default = "ident" ;
  5016.   
  5017.  
  5018.         fn2.caption="Function 2";
  5019.         fn2.default = "ident" ;
  5020.   
  5021.     }
  5022. }
  5023.  
  5024.  
  5025. gpm-ca07-01 {//chby1 / ca07-01 formula by Morgan L. Owens
  5026.              //Translated from .frm to .ufm
  5027.              //and slightly modified by Gedeon Peteri, April 1999
  5028. complex t;
  5029. parameter complex p1;
  5030. complex a;
  5031. parameter complex p2;
  5032. complex b;
  5033. complex c;
  5034. complex d;
  5035. complex k;
  5036. complex Var_x;
  5037. complex Var_y;
  5038. complex xx;
  5039. complex yy;
  5040. complex tx;
  5041. complex ty;
  5042. parameter real bailout;
  5043.  
  5044.     void init(void)
  5045.     {
  5046.         z=fn4(pixel);
  5047.         t=p1;
  5048.         a=p2;
  5049.         b=a*(a*(a*(a+6)+11)+6)/21;
  5050.         c=a+a+8;
  5051.         d=((a+a)*(a+11)+60)/15;
  5052.         k=7*(a+5)/5;
  5053.     }
  5054.     void loop(void)
  5055.     {
  5056.         Var_x=real(z);
  5057.         Var_y=imag(z);
  5058.         xx=Var_x*Var_x;
  5059.         yy=Var_y*Var_y;
  5060.         tx=fn1(b*Var_x*(c*xx*((xx+xx)*(d*xx-k)+7)-7));
  5061.         ty=fn2(b*Var_y*(c*yy*((yy+yy)*(d*yy-k)+7)-7));
  5062.         Var_x=Var_x-t*ty;
  5063.         Var_y=Var_y+t*tx;
  5064.         z=fn3(Var_x+flip(Var_y));
  5065.     }
  5066.     bool bailout(void)
  5067.     {
  5068.         return(|z|<=bailout);
  5069.     }
  5070.     void description(void)
  5071.     {
  5072.         this.title="gpm-ca07-01";
  5073.  
  5074.         p1.caption="Parameter 1";
  5075.         p1.default=(1.0,1.0);
  5076.    
  5077.  
  5078.         p2.caption="Parameter 2";
  5079.         p2.default=(0.5,0.5);
  5080.    
  5081.  
  5082.         bailout.caption="Bailout";
  5083.         bailout.default=4.0;
  5084.    
  5085.  
  5086.         fn1.caption="Function 1";
  5087.         fn1.default = "ident" ;
  5088.   
  5089.  
  5090.         fn2.caption="Function 2";
  5091.         fn2.default = "ident" ;
  5092.   
  5093.  
  5094.         fn3.caption="Function 3";
  5095.         fn3.default = "ident" ;
  5096.   
  5097.  
  5098.         fn4.caption="Function 4";
  5099.         fn4.default = "ident" ;
  5100.   
  5101.     }
  5102. }
  5103.  
  5104.  
  5105. gpm-exp03-01{//chby1 / exp03-01 formula by Morgan L. Owens
  5106.              //Translated from .frm to .ufm
  5107.              //and slightly modified by Gedeon Peteri, March 1999
  5108. complex t;
  5109. parameter complex p1;
  5110. complex Var_x;
  5111. complex Var_y;
  5112. complex fx;
  5113. complex fy;
  5114. parameter real bailout;
  5115.  
  5116.     void init(void)
  5117.     {
  5118.         z=fn3(pixel);
  5119.         t=p1;
  5120.     }
  5121.     void loop(void)
  5122.     {
  5123.         Var_x=real(z);
  5124.         Var_y=imag(z);
  5125.         fx=fn1((1-Var_x)/(exp(Var_x)*2));
  5126.         fy=fn2((1-Var_y)/(exp(Var_y)*2));
  5127.         Var_x=Var_x-t*fy;
  5128.         Var_y=Var_y+t*fx;
  5129.         z=Var_x+fn4(Var_y);
  5130.     }
  5131.     bool bailout(void)
  5132.     {
  5133.         return(|z|<=bailout);
  5134.     }
  5135.     void description(void)
  5136.     {
  5137.         this.title="gpm-exp03-01";
  5138.  
  5139.         p1.caption="Parameter";
  5140.         p1.default=(1.0,0.0);
  5141.    
  5142.  
  5143.         bailout.caption="Bailout";
  5144.         bailout.default=4.0;
  5145.    
  5146.  
  5147.         fn1.caption="Function 1";
  5148.         fn1.default = "ident" ;
  5149.   
  5150.  
  5151.         fn2.caption="Function 2";
  5152.         fn2.default = "ident" ;
  5153.   
  5154.  
  5155.         fn3.caption="Function 3";
  5156.         fn3.default = "ident" ;
  5157.   
  5158.  
  5159.         fn4.caption="Function 4";
  5160.         fn4.default = "flip" ;
  5161.   
  5162.     }
  5163. }
  5164.  
  5165.  
  5166. gpm-exp06-27{//chby27 / exp06-27 formula by Morgan L. Owens
  5167.              //Translated from .frm to .ufm
  5168.              //and slightly modified by Gedeon Peteri, March 1999
  5169. complex t;
  5170. parameter complex p1;
  5171. complex h;
  5172. parameter complex p2;
  5173. complex Var_x;
  5174. complex Var_y;
  5175. complex newx;
  5176. complex newy;
  5177. complex tx;
  5178. complex ty;
  5179. parameter real bailout;
  5180.  
  5181.     void init(void)
  5182.     {
  5183.         z=fn3(pixel);
  5184.         t=p1;
  5185.         h=p2;
  5186.         Var_x=real(pixel);
  5187.         Var_y=imag(pixel);
  5188.     }
  5189.     void loop(void)
  5190.     {
  5191.         newx=Var_x-h*sin(Var_y+tan(3*Var_y));
  5192.         newy=Var_y-h*sin(Var_x+tan(3*Var_x));
  5193.         Var_x=newx;
  5194.         Var_y=newy;
  5195.         tx=fn1(((((Var_x-1)*Var_x/120+1/60)*Var_x-1/20)*Var_x+1/5)/exp(Var_x));
  5196.         ty=fn2(((((Var_y-1)*Var_y/120+1/60)*Var_y-1/20)*Var_y+1/5)/exp(Var_y));
  5197.         Var_x=Var_x-t*ty;
  5198.         Var_y=Var_y+t*tx;
  5199.         z=Var_x+fn4(Var_y);
  5200.     }
  5201.     bool bailout(void)
  5202.     {
  5203.         return(|z|<=bailout);
  5204.     }
  5205.     void description(void)
  5206.     {
  5207.         this.title="gpm-exp06-27";
  5208.  
  5209.         p1.caption="Parameter 1";
  5210.         p1.default=(0.5,0.0);
  5211.    
  5212.  
  5213.         p2.caption="Parameter 2";
  5214.         p2.default=(1.0,0.0);
  5215.    
  5216.  
  5217.         bailout.caption="Bailout";
  5218.         bailout.default=4.0;
  5219.    
  5220.  
  5221.         fn1.caption="Function 1";
  5222.         fn1.default = "ident" ;
  5223.   
  5224.  
  5225.         fn2.caption="Function 2";
  5226.         fn2.default = "ident" ;
  5227.   
  5228.  
  5229.         fn3.caption="Function 3";
  5230.         fn3.default = "ident" ;
  5231.   
  5232.  
  5233.         fn4.caption="Function 4";
  5234.         fn4.default = "flip" ;
  5235.   
  5236.     }
  5237. }
  5238.  
  5239.  
  5240. gpm-h04-14 {//chby14 / h04-14 formula by Morgan L. Owens
  5241.             //Translated from .frm to .ufm
  5242.             //and slightly modified by Gedeon Peteri, November 1999
  5243. complex zz;
  5244. complex f;
  5245. parameter complex p1;
  5246. complex fd;
  5247. parameter complex p2;
  5248. complex oz;
  5249. complex w;
  5250. complex ww;
  5251. complex fw;
  5252. parameter complex p3;
  5253. parameter real bailout;
  5254.  
  5255.     void init(void)
  5256.     {
  5257.         z=fn4(pixel);
  5258.     }
  5259.     void loop(void)
  5260.     {
  5261.         zz=z*z;
  5262.         f=p1*fn1(4*(4*zz*(zz-3)+3));
  5263.         fd=p2*fn2(32*z*(zz+zz-3));
  5264.         oz=z;
  5265.         w=z-f/fd;
  5266.         ww=w*w;
  5267.         fw=p3*fn3(4*(4*ww*(ww-3)+3));
  5268.         z=w-fw/fd;
  5269.     }
  5270.     bool bailout(void)
  5271.     {
  5272.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  5273.     }
  5274.     void description(void)
  5275.     {
  5276.         this.title="gpm-h04-14";
  5277.  
  5278.         p1.caption="Parameter 1";
  5279.         p1.default=(2.0,0.0);
  5280.    
  5281.  
  5282.         p2.caption="Parameter 2";
  5283.         p2.default=(1.0,0.0);
  5284.    
  5285.  
  5286.         p3.caption="Parameter 3";
  5287.         p3.default=(1.0,0.0);
  5288.    
  5289.  
  5290.         bailout.caption="Bailout";
  5291.         bailout.default=1.0;
  5292.    
  5293.  
  5294.         fn1.caption="Function 1";
  5295.         fn1.default = "ident" ;
  5296.   
  5297.  
  5298.         fn2.caption="Function 2";
  5299.         fn2.default = "ident" ;
  5300.   
  5301.  
  5302.         fn3.caption="Function 3";
  5303.         fn3.default = "ident" ;
  5304.   
  5305.  
  5306.         fn4.caption="Function 4";
  5307.         fn4.default = "ident" ;
  5308.   
  5309.     }
  5310. }
  5311.  
  5312.  
  5313. gpm-h04-15 {//chby15 / h04-14 formula by Morgan L. Owens
  5314.             //Translated from .frm to .ufm
  5315.             //and slightly modified by Gedeon Peteri, November 1999
  5316. complex r;
  5317. parameter complex p1;
  5318. complex zz;
  5319. complex f;
  5320. parameter complex p2;
  5321. complex fd;
  5322. parameter complex p3;
  5323. complex oz;
  5324. parameter real bailout;
  5325.  
  5326.     void init(void)
  5327.     {
  5328.         z=fn4(pixel);
  5329.         r=p1;
  5330.     }
  5331.     void loop(void)
  5332.     {
  5333.         zz=z*z;
  5334.         f=p2*fn1(4*(4*zz*(zz-3)+3));
  5335.         fd=p3*fn2(32*z*(2*zz-3));
  5336.         oz=z;
  5337.         z=fn3(z-r*f/fd);
  5338.     }
  5339.     bool bailout(void)
  5340.     {
  5341.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  5342.     }
  5343.     void description(void)
  5344.     {
  5345.         this.title="gpm-h04-15";
  5346.  
  5347.         p1.caption="Parameter 1";
  5348.         p1.default=(2.0,2.0);
  5349.    
  5350.  
  5351.         p2.caption="Parameter 2";
  5352.         p2.default=(1.0,0.0);
  5353.    
  5354.  
  5355.         p3.caption="Parameter 3";
  5356.         p3.default=(1.0,0.0);
  5357.    
  5358.  
  5359.         bailout.caption="Bailout";
  5360.         bailout.default=1.0;
  5361.    
  5362.  
  5363.         fn1.caption="Function 1";
  5364.         fn1.default = "ident" ;
  5365.   
  5366.  
  5367.         fn2.caption="Function 2";
  5368.         fn2.default = "ident" ;
  5369.   
  5370.  
  5371.         fn3.caption="Function 3";
  5372.         fn3.default = "ident" ;
  5373.   
  5374.  
  5375.         fn4.caption="Function 4";
  5376.         fn4.default = "ident" ;
  5377.   
  5378.     }
  5379. }
  5380.  
  5381.  
  5382. gpm-h04-26  {//chby26 / h04-26 formula by Morgan L. Owens
  5383.              //Translated from .frm to .ufm
  5384.              //and slightly modified by Gedeon Peteri, October 1999
  5385. complex t;
  5386. parameter complex p1;
  5387. complex v;
  5388. parameter complex p3;
  5389. complex Var_x;
  5390. complex Var_y;
  5391. complex xx;
  5392. complex tx;
  5393. complex yy;
  5394. complex ty;
  5395. complex w;
  5396. parameter complex p2;
  5397. parameter real bailout;
  5398.  
  5399.     void init(void)
  5400.     {
  5401.         z=fn4(pixel);
  5402.         t=p1;
  5403.         v=p3;
  5404.     }
  5405.     void loop(void)
  5406.     {
  5407.         Var_x=real(z);
  5408.         Var_y=imag(z);
  5409.         xx=Var_x*Var_x;
  5410.         tx=(fn1(4*(4*xx*(xx-3)+3)));
  5411.         yy=Var_y*Var_y;
  5412.         ty=(fn1(4*(4*yy*(yy-3)+3)));
  5413.         Var_x=Var_x-t*ty;
  5414.         Var_y=Var_y+t*tx;
  5415.         w=fn1(Var_x+flip(Var_y));
  5416.         z=fn3(v/fn2(w*w))+p2;
  5417.     }
  5418.     bool bailout(void)
  5419.     {
  5420.         return(|z|<=bailout);
  5421.     }
  5422.     void description(void)
  5423.     {
  5424.         this.title="gpm-h04-26";
  5425.  
  5426.         p1.caption="Parameter 1";
  5427.         p1.default=(0.1,0.0);
  5428.    
  5429.  
  5430.         p2.caption="Parameter 2";
  5431.         p2.default=(1.0,0.0);
  5432.    
  5433.  
  5434.         p3.caption="Parameter 3";
  5435.         p3.default=(1.0,0.0);
  5436.    
  5437.  
  5438.         bailout.caption="Bailout";
  5439.         bailout.default=4.0;
  5440.    
  5441.  
  5442.         fn1.caption="Function 1";
  5443.         fn1.default = "ident" ;
  5444.   
  5445.  
  5446.         fn2.caption="Function 2";
  5447.         fn2.default = "ident" ;
  5448.   
  5449.  
  5450.         fn3.caption="Function 3";
  5451.         fn3.default = "ident" ;
  5452.   
  5453.  
  5454.         fn4.caption="Function 4";
  5455.         fn4.default = "ident" ;
  5456.   
  5457.     }
  5458. }
  5459.  
  5460.  
  5461. gpm-h06-13  {//chby13 / h06-13 formula by Morgan L. Owens
  5462.              //Translated from .frm to .ufm
  5463.              //and slightly modified by Gedeon Peteri, October 1999
  5464. complex r;
  5465. parameter complex p1;
  5466. complex zz;
  5467. complex a;
  5468. complex f;
  5469. complex fd;
  5470. complex fdd;
  5471. complex oz;
  5472. parameter real bailout;
  5473.  
  5474.     void init(void)
  5475.     {
  5476.         z=fn4(pixel);
  5477.         r=p1;
  5478.     }
  5479.     void loop(void)
  5480.     {
  5481.         zz=z*z;
  5482.         a=2*zz;
  5483.         f=fn1(8*(a*(a*(a-15)+21)-15));
  5484.         fd=fn2(96*z*(4*zz*(zz-5)+7));
  5485.         fdd=fn3(96*(20*zz*(zz-3)+7));
  5486.         oz=z;
  5487.         z=z-r*f/(fd-fdd*f/(fd+fd));
  5488.     }
  5489.     bool bailout(void)
  5490.     {
  5491.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  5492.     }
  5493.     void description(void)
  5494.     {
  5495.         this.title="gpm-h06-13";
  5496.  
  5497.         p1.caption="Parameter";
  5498.         p1.default=(2.0,0.0);
  5499.    
  5500.  
  5501.         bailout.caption="Bailout";
  5502.         bailout.default=1.0;
  5503.    
  5504.  
  5505.         fn1.caption="Function 1";
  5506.         fn1.default = "ident" ;
  5507.   
  5508.  
  5509.         fn2.caption="Function 2";
  5510.         fn2.default = "ident" ;
  5511.   
  5512.  
  5513.         fn3.caption="Function 3";
  5514.         fn3.default = "ident" ;
  5515.   
  5516.  
  5517.         fn4.caption="Function 4";
  5518.         fn4.default = "ident" ;
  5519.   
  5520.     }
  5521. }
  5522.  
  5523.  
  5524. gpm-he02-01 {//chby1 / he02-01 formula by Morgan L. Owens
  5525.              //Translated from .frm to .ufm
  5526.              //and slightly modified by Gedeon Peteri, April 1999
  5527. complex t;
  5528. parameter complex p1;
  5529. complex s;
  5530. complex Var_x;
  5531. complex Var_y;
  5532. complex tx;
  5533. parameter complex p2;
  5534. complex ty;
  5535. parameter complex p3;
  5536. parameter real bailout;
  5537.  
  5538.     void init(void)
  5539.     {
  5540.         z=fn3(pixel);
  5541.         t=p1;
  5542.         s=sqrt(2);
  5543.     }
  5544.     void loop(void)
  5545.     {
  5546.         Var_x=real(z);
  5547.         Var_y=imag(z);
  5548.         tx=p2*fn1(s*Var_x*Var_x-1);
  5549.         ty=p3*fn2(s*Var_y*Var_y-1);
  5550.         Var_x=Var_x-t*ty;
  5551.         Var_y=Var_y+t*tx;
  5552.         z=Var_x+fn4(Var_y);
  5553.     }
  5554.     bool bailout(void)
  5555.     {
  5556.         return(|z|<=bailout);
  5557.     }
  5558.     void description(void)
  5559.     {
  5560.         this.title="gpm-he02-01";
  5561.  
  5562.         p1.caption="Parameter 1";
  5563.         p1.default=(1.0,0.0);
  5564.    
  5565.  
  5566.         p2.caption="Parameter 2";
  5567.         p2.default=(1.0,0.0);
  5568.    
  5569.  
  5570.         p3.caption="Parameter 3";
  5571.         p3.default=(1.0,0.0);
  5572.    
  5573.  
  5574.         bailout.caption="Bailout";
  5575.         bailout.default=4.0;
  5576.    
  5577.  
  5578.         fn1.caption="Function 1";
  5579.         fn1.default = "ident" ;
  5580.   
  5581.  
  5582.         fn2.caption="Function 2";
  5583.         fn2.default = "ident" ;
  5584.   
  5585.  
  5586.         fn3.caption="Function 3";
  5587.         fn3.default = "ident" ;
  5588.   
  5589.  
  5590.         fn4.caption="Function 4";
  5591.         fn4.default = "flip" ;
  5592.   
  5593.     }
  5594. }
  5595.  
  5596.  
  5597. gpm-he02-15 {//chby15 / he02-15 formula by Morgan L. Owens
  5598.              //Translated from .frm to .ufm
  5599.              //and slightly modified by Gedeon Peteri, March 1999
  5600. complex r;
  5601. parameter complex p1;
  5602. complex s;
  5603. complex a;
  5604. complex f;
  5605. complex fd;
  5606. complex oz;
  5607. parameter real bailout;
  5608.  
  5609.     void init(void)
  5610.     {
  5611.         z=fn3(pixel);
  5612.         r=p1;
  5613.         s=sqrt(2);
  5614.         a=2*s;
  5615.     }
  5616.     void loop(void)
  5617.     {
  5618.         f=fn1(s*z*z-1);
  5619.         fd=fn2(a*z);
  5620.         oz=z;
  5621.         z=z-r*f/fd;
  5622.     }
  5623.     bool bailout(void)
  5624.     {
  5625.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  5626.     }
  5627.     void description(void)
  5628.     {
  5629.         this.title="gpm-he02-15";
  5630.  
  5631.         p1.caption="Parameter";
  5632.         p1.default=(1.0,1.0);
  5633.    
  5634.  
  5635.         bailout.caption="Bailout";
  5636.         bailout.default=1.0;
  5637.    
  5638.  
  5639.         fn1.caption="Function 1";
  5640.         fn1.default = "ident" ;
  5641.   
  5642.  
  5643.         fn2.caption="Function 2";
  5644.         fn2.default = "ident" ;
  5645.   
  5646.  
  5647.         fn3.caption="Function 3";
  5648.         fn3.default = "ident" ;
  5649.   
  5650.     }
  5651. }
  5652.  
  5653.  
  5654. gpm-he08-20 {//chby20 / he08-20 formula by Morgan L. Owens
  5655.              //Translated from .frm to .ufm
  5656.              //and slightly modified by Gedeon Peteri, March 1999
  5657. complex t;
  5658. parameter complex p1;
  5659. complex s;
  5660. complex a;
  5661. complex b;
  5662. complex Var_x;
  5663. complex Var_y;
  5664. complex xx;
  5665. complex yy;
  5666. parameter real bailout;
  5667.  
  5668.     void init(void)
  5669.     {
  5670.         z=fn3(pixel);
  5671.         t=p1;
  5672.         s=sqrt(2);
  5673.         a=185*s+25;
  5674.         b=41*s-141;
  5675.     }
  5676.     void loop(void)
  5677.     {
  5678.         Var_x=real(z);
  5679.         Var_y=imag(z);
  5680.         xx=Var_x*Var_x;
  5681.         yy=Var_y*Var_y;
  5682.         Var_y=Var_y+t*(fn1(xx*(xx*(xx*(s*(xx-27)-1)+a)+b)+105));
  5683.         Var_x=Var_x-t*(fn2(yy*(yy*(yy*(s*(yy-27)-1)+a)+b)+105));
  5684.         z=Var_x+fn4(Var_y);
  5685.     }
  5686.     bool bailout(void)
  5687.     {
  5688.         return(|z|<=bailout);
  5689.     }
  5690.     void description(void)
  5691.     {
  5692.         this.title="gpm-he08-20";
  5693.  
  5694.         p1.caption="Parameter";
  5695.         p1.default=(1.0,0.0);
  5696.    
  5697.  
  5698.         bailout.caption="Bailout";
  5699.         bailout.default=4.0;
  5700.    
  5701.  
  5702.         fn1.caption="Function 1";
  5703.         fn1.default = "sin" ;
  5704.   
  5705.  
  5706.         fn2.caption="Function 2";
  5707.         fn2.default = "sin" ;
  5708.   
  5709.  
  5710.         fn3.caption="Function 3";
  5711.         fn3.default = "ident" ;
  5712.   
  5713.  
  5714.         fn4.caption="Function 4";
  5715.         fn4.default = "flip" ;
  5716.   
  5717.     }
  5718. }
  5719.  
  5720.  
  5721. gpm-l02-01  {//chby1 / l02-01 formula by Morgan L. Owens
  5722.              //Translated from .frm to .ufm
  5723.              //and slightly modified by Gedeon Peteri, November 1999
  5724. complex t;
  5725. parameter complex p1;
  5726. complex Var_x;
  5727. complex Var_y;
  5728. complex tx;
  5729. parameter complex p2;
  5730. complex ty;
  5731. parameter complex p3;
  5732. parameter real bailout;
  5733.  
  5734.     void init(void)
  5735.     {
  5736.         z=fn4(pixel);
  5737.         t=p1;
  5738.     }
  5739.     void loop(void)
  5740.     {
  5741.         Var_x=real(z);
  5742.         Var_y=imag(z);
  5743.         tx=p2*fn1(Var_x*(Var_x/2-2)+1);
  5744.         ty=p3*fn2(Var_y*(Var_y/2-2)+1);
  5745.         Var_x=Var_x-t*ty;
  5746.         Var_y=Var_y+t*tx;
  5747.         z=Var_x+fn3(Var_y);
  5748.     }
  5749.     bool bailout(void)
  5750.     {
  5751.         return(|z|<=bailout);
  5752.     }
  5753.     void description(void)
  5754.     {
  5755.         this.title="gpm-l02-01";
  5756.  
  5757.         p1.caption="Parameter 1";
  5758.         p1.default=(0.5,0.0);
  5759.    
  5760.  
  5761.         p2.caption="Parameter 2";
  5762.         p2.default=(1.0,0.0);
  5763.    
  5764.  
  5765.         p3.caption="Parameter 3";
  5766.         p3.default=(1.0,0.0);
  5767.    
  5768.  
  5769.         bailout.caption="Bailout";
  5770.         bailout.default=4.0;
  5771.    
  5772.  
  5773.         fn1.caption="Function 1";
  5774.         fn1.default = "ident" ;
  5775.   
  5776.  
  5777.         fn2.caption="Function 2";
  5778.         fn2.default = "ident" ;
  5779.   
  5780.  
  5781.         fn3.caption="Function 3";
  5782.         fn3.default = "flip" ;
  5783.   
  5784.  
  5785.         fn4.caption="Function 4";
  5786.         fn4.default = "ident" ;
  5787.   
  5788.     }
  5789. }
  5790.  
  5791.  
  5792. gpm-l08-13 {//chby13 / l08-13 formula by Morgan L. Owens
  5793.             //Translated from .frm to .ufm
  5794.             //and slightly modified by Gedeon Peteri, March 1999
  5795. complex f;
  5796. complex fd;
  5797. complex fdd;
  5798. complex oz;
  5799. parameter complex p1;
  5800. parameter real bailout;
  5801.  
  5802.     void init(void)
  5803.     {
  5804.         z=fn4(pixel);
  5805.     }
  5806.     void loop(void)
  5807.     {
  5808.         f=fn1(z*(z*(z*(z*(z*(z*(z*(z/32-2)/7+7)/3-28)/5+35)/4-28)/3+14)-8)+1);
  5809.         fd=fn2(z*(z*(z*(z*(z*(z*(z/28-2)/3+14)/20-7)+35)/3-28)+28)-8);
  5810.         fdd=fn3((z*(z*(z*(z*(z*(z/12-4)+70)/20-28)/3+35)-56)+28));
  5811.         oz=z;
  5812.         z=z-p1*(f/(fd-fdd*f/(fd+fd)));
  5813.     }
  5814.     bool bailout(void)
  5815.     {
  5816.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  5817.     }
  5818.     void description(void)
  5819.     {
  5820.         this.title="gpm-l08-13";
  5821.  
  5822.         p1.caption="Parameter";
  5823.         p1.default=(2.0,1.0);
  5824.    
  5825.  
  5826.         bailout.caption="Bailout";
  5827.         bailout.default=1.0;
  5828.    
  5829.  
  5830.         fn1.caption="Function 1";
  5831.         fn1.default = "ident" ;
  5832.   
  5833.  
  5834.         fn2.caption="Function 2";
  5835.         fn2.default = "ident" ;
  5836.   
  5837.  
  5838.         fn3.caption="Function 3";
  5839.         fn3.default = "ident" ;
  5840.   
  5841.  
  5842.         fn4.caption="Function 4";
  5843.         fn4.default = "ident" ;
  5844.   
  5845.     }
  5846. }
  5847.  
  5848.  
  5849. gpm-la08-01{//chby1 / la08-01 formula by Morgan L. Owens
  5850.             //Translated from .frm to .ufm
  5851.             //and slightly modified by Gedeon Peteri, April 1999
  5852. complex t;
  5853. parameter complex p1;
  5854. complex a;
  5855. parameter complex p2;
  5856. complex j;
  5857. complex h;
  5858. complex g;
  5859. complex f;
  5860. complex k;
  5861. complex d;
  5862. complex c;
  5863. complex b;
  5864. complex Var_x;
  5865. complex Var_y;
  5866. complex tx;
  5867. complex ty;
  5868. parameter real bailout;
  5869.  
  5870.     void init(void)
  5871.     {
  5872.         z=fn4(pixel);
  5873.         t=p1;
  5874.         a=p2;
  5875.         j=(a+8)/5040;
  5876.         h=j*(a+7)*(7/2);
  5877.         g=h*(a+6)*2;
  5878.         f=g*(a+5)*(5/4);
  5879.         k=f*(a+4)*(4/5);
  5880.         d=k*(a+3)/2;
  5881.         c=d*(a+2)*(2/7);
  5882.         b=c*(a+1)/8;
  5883.     }
  5884.     void loop(void)
  5885.     {
  5886.         Var_x=real(z);
  5887.         Var_y=imag(z);
  5888.         tx=fn1(Var_x*(Var_x*(Var_x*(Var_x*(Var_x*(Var_x*(Var_x*(Var_x/40320-j)+h)-g)+f)-k)+d)-c)+b);
  5889.         ty=fn2(Var_y*(Var_y*(Var_y*(Var_y*(Var_y*(Var_y*(Var_y*(Var_y/40320-j)+h)-g)+f)-k)+d)-c)+b);
  5890.         Var_x=Var_x-t*ty;
  5891.         Var_y=Var_y+t*tx;
  5892.         z=fn3(Var_x+flip(Var_y));
  5893.     }
  5894.     bool bailout(void)
  5895.     {
  5896.         return(|z|<=bailout);
  5897.     }
  5898.     void description(void)
  5899.     {
  5900.         this.title="gpm-la08-01";
  5901.  
  5902.         p1.caption="Parameter 1";
  5903.         p1.default=(0.1,0.0);
  5904.    
  5905.  
  5906.         p2.caption="Parameter 2";
  5907.         p2.default=(0.1,0.0);
  5908.    
  5909.  
  5910.         bailout.caption="Bailout";
  5911.         bailout.default=4.0;
  5912.    
  5913.  
  5914.         fn1.caption="Function 1";
  5915.         fn1.default = "ident" ;
  5916.   
  5917.  
  5918.         fn2.caption="Function 2";
  5919.         fn2.default = "ident" ;
  5920.   
  5921.  
  5922.         fn3.caption="Function 3";
  5923.         fn3.default = "ident" ;
  5924.   
  5925.  
  5926.         fn4.caption="Function 4";
  5927.         fn4.default = "ident" ;
  5928.   
  5929.     }
  5930. }
  5931.  
  5932.  
  5933. gpm-p03-01  {//chby1 / p03-01 formula by Morgan L. Owens
  5934.              //Translated from .frm to .ufm
  5935.              //and slightly modified by Gedeon Peteri, November 1999
  5936. complex t;
  5937. parameter complex p1;
  5938. complex Var_x;
  5939. complex Var_y;
  5940. complex tx;
  5941. parameter complex p2;
  5942. complex ty;
  5943. parameter complex p3;
  5944. parameter real bailout;
  5945.  
  5946.     void init(void)
  5947.     {
  5948.         z=fn4(pixel);
  5949.         t=p1;
  5950.     }
  5951.     void loop(void)
  5952.     {
  5953.         Var_x=real(z);
  5954.         Var_y=imag(z);
  5955.         tx=p2*fn1(Var_x*(5*Var_x*Var_x-3)/2);
  5956.         ty=p3*fn2(Var_y*(5*Var_y*Var_y-3)/2);
  5957.         Var_x=Var_x-t*ty;
  5958.         Var_y=Var_y+t*tx;
  5959.         z=Var_x+fn3(Var_y);
  5960.     }
  5961.     bool bailout(void)
  5962.     {
  5963.         return(|z|<=bailout);
  5964.     }
  5965.     void description(void)
  5966.     {
  5967.         this.title="gpm-p03-01";
  5968.  
  5969.         p1.caption="Parameter 1";
  5970.         p1.default=(1.0,0.0);
  5971.    
  5972.  
  5973.         p2.caption="Parameter 2";
  5974.         p2.default=(1.0,0.0);
  5975.    
  5976.  
  5977.         p3.caption="Parameter 3";
  5978.         p3.default=(1.0,0.0);
  5979.    
  5980.  
  5981.         bailout.caption="Bailout";
  5982.         bailout.default=4.0;
  5983.    
  5984.  
  5985.         fn1.caption="Function 1";
  5986.         fn1.default = "ident" ;
  5987.   
  5988.  
  5989.         fn2.caption="Function 2";
  5990.         fn2.default = "ident" ;
  5991.   
  5992.  
  5993.         fn3.caption="Function 3";
  5994.         fn3.default = "flip" ;
  5995.   
  5996.  
  5997.         fn4.caption="Function 4";
  5998.         fn4.default = "ident" ;
  5999.   
  6000.     }
  6001. }
  6002.  
  6003.  
  6004. gpm-p04-23 {//chby23 / p04-23 formula by Morgan L. Owens
  6005.             //Translated from .frm to .ufm
  6006.             //and slightly modified by Gedeon Peteri, March 1999
  6007. complex t;
  6008. parameter complex p1;
  6009. complex Var_x;
  6010. complex Var_y;
  6011. complex xx;
  6012. complex yy;
  6013. complex tx;
  6014. complex ty;
  6015. parameter real bailout;
  6016.  
  6017.     void init(void)
  6018.     {
  6019.         z=fn3(pixel);
  6020.         t=p1;
  6021.     }
  6022.     void loop(void)
  6023.     {
  6024.         Var_x=real(z);
  6025.         Var_y=imag(z);
  6026.         xx=Var_x*Var_x;
  6027.         yy=Var_y*Var_y;
  6028.         tx=fn1((5*xx*(7*xx-6)+3)/8);
  6029.         ty=fn2((5*yy*(7*yy-6)+3)/8);
  6030.         Var_x=Var_x-t*ty;
  6031.         Var_y=Var_y+t*tx;
  6032.         z=Var_x+fn4(Var_y);
  6033.     }
  6034.     bool bailout(void)
  6035.     {
  6036.         return(|z|<=bailout);
  6037.     }
  6038.     void description(void)
  6039.     {
  6040.         this.title="gpm-p04-23";
  6041.  
  6042.         p1.caption="Parameter";
  6043.         p1.default=(1.0,0.0);
  6044.    
  6045.  
  6046.         bailout.caption="Bailout";
  6047.         bailout.default=4.0;
  6048.    
  6049.  
  6050.         fn1.caption="Function 1";
  6051.         fn1.default = "sin" ;
  6052.   
  6053.  
  6054.         fn2.caption="Function 2";
  6055.         fn2.default = "sin" ;
  6056.   
  6057.  
  6058.         fn3.caption="Function 3";
  6059.         fn3.default = "ident" ;
  6060.   
  6061.  
  6062.         fn4.caption="Function 4";
  6063.         fn4.default = "flip" ;
  6064.   
  6065.     }
  6066. }
  6067.  
  6068.  
  6069. gpm-p06-01  {//chby1 / p06-01 formula by Morgan L. Owens
  6070.              //Translated from .frm to .ufm
  6071.              //and slightly modified by Gedeon Peteri, November 1999
  6072. complex t;
  6073. parameter complex p1;
  6074. complex Var_x;
  6075. complex Var_y;
  6076. complex xx;
  6077. complex yy;
  6078. complex tx;
  6079. parameter complex p2;
  6080. complex ty;
  6081. parameter complex p3;
  6082. parameter real bailout;
  6083.  
  6084.     void init(void)
  6085.     {
  6086.         z=fn4(pixel);
  6087.         t=p1;
  6088.     }
  6089.     void loop(void)
  6090.     {
  6091.         Var_x=real(z);
  6092.         Var_y=imag(z);
  6093.         xx=Var_x*Var_x;
  6094.         yy=Var_y*Var_y;
  6095.         tx=p2*fn1((21*xx*(xx*(11*xx-15)+5)-5)/16);
  6096.         ty=p3*fn2((21*yy*(yy*(11*yy-15)+5)-5)/16);
  6097.         Var_x=Var_x-t*ty;
  6098.         Var_y=Var_y+t*tx;
  6099.         z=Var_x+fn3(Var_y);
  6100.     }
  6101.     bool bailout(void)
  6102.     {
  6103.         return(|z|<bailout);
  6104.     }
  6105.     void description(void)
  6106.     {
  6107.         this.title="gpm-p06-01";
  6108.  
  6109.         p1.caption="Parameter 1";
  6110.         p1.default=(1.0,0.0);
  6111.    
  6112.  
  6113.         p2.caption="Parameter 2";
  6114.         p2.default=(1.0,0.0);
  6115.    
  6116.  
  6117.         p3.caption="Parameter 3";
  6118.         p3.default=(1.0,0.0);
  6119.    
  6120.  
  6121.         bailout.caption="Bailout";
  6122.         bailout.default=100.0;
  6123.    
  6124.  
  6125.         fn1.caption="Function 1";
  6126.         fn1.default = "ident" ;
  6127.   
  6128.  
  6129.         fn2.caption="Function 2";
  6130.         fn2.default = "ident" ;
  6131.   
  6132.  
  6133.         fn3.caption="Function 3";
  6134.         fn3.default = "flip" ;
  6135.   
  6136.  
  6137.         fn4.caption="Function 4";
  6138.         fn4.default = "ident" ;
  6139.   
  6140.     }
  6141. }
  6142.  
  6143.  
  6144. gpm-p06-03  {//chby3 / p06-03 formula by Morgan L. Owens
  6145.              //Translated from .frm to .ufm
  6146.              //and slightly modified by Gedeon Peteri, March 1999
  6147. complex c;
  6148. parameter complex p1;
  6149. complex zz;
  6150. parameter real bailout;
  6151.  
  6152.     void init(void)
  6153.     {
  6154.         z=fn2(pixel);
  6155.         c=p1;
  6156.     }
  6157.     void loop(void)
  6158.     {
  6159.         zz=z*z;
  6160.         z=fn1(21*zz*(zz*(11*zz-15)+5)-5)/16+c;
  6161.     }
  6162.     bool bailout(void)
  6163.     {
  6164.         return(|z|<bailout);
  6165.     }
  6166.     void description(void)
  6167.     {
  6168.         this.title="gpm-p06-03";
  6169.  
  6170.         p1.caption="Parameter";
  6171.         p1.default=(0.3,0.0);
  6172.    
  6173.  
  6174.         bailout.caption="Bailout";
  6175.         bailout.default=100.0;
  6176.    
  6177.  
  6178.         fn1.caption="Function 1";
  6179.         fn1.default = "ident" ;
  6180.   
  6181.  
  6182.         fn2.caption="Function 2";
  6183.         fn2.default = "ident" ;
  6184.   
  6185.     }
  6186. }
  6187.  
  6188.  
  6189. gpm-p08-15  {//chby15 / p08-15 formula by Morgan L. Owens
  6190.              //Translated from .frm to .ufm
  6191.              //and slightly modified by Gedeon Peteri, April 1999
  6192. complex r;
  6193. parameter complex p1;
  6194. complex zz;
  6195. complex f;
  6196. complex fd;
  6197. complex oz;
  6198. parameter real bailout;
  6199.  
  6200.     void init(void)
  6201.     {
  6202.         z=fn4(pixel);
  6203.         r=p1;
  6204.     }
  6205.     void loop(void)
  6206.     {
  6207.         zz=z*z;
  6208.         f=fn1((3*zz*(11*zz*(13*zz*(15*zz-28)+210)-420)+35)/128);
  6209.         fd=fn2(9*z*(11*zz*(39*zz*(5*zz-7)+35)-35)/16);
  6210.         oz=z;
  6211.         z=z-fn3(r*f/fd);
  6212.     }
  6213.     bool bailout(void)
  6214.     {
  6215.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  6216.     }
  6217.     void description(void)
  6218.     {
  6219.         this.title="gpm-p08-15";
  6220.  
  6221.         p1.caption="Parameter";
  6222.         p1.default=(2.0,2.0);
  6223.    
  6224.  
  6225.         bailout.caption="Bailout";
  6226.         bailout.default=0.005;
  6227.    
  6228.  
  6229.         fn1.caption="Function 1";
  6230.         fn1.default = "ident" ;
  6231.   
  6232.  
  6233.         fn2.caption="Function 2";
  6234.         fn2.default = "ident" ;
  6235.   
  6236.  
  6237.         fn3.caption="Function 3";
  6238.         fn3.default = "ident" ;
  6239.   
  6240.  
  6241.         fn4.caption="Function 4";
  6242.         fn4.default = "ident" ;
  6243.   
  6244.     }
  6245. }
  6246.  
  6247.  
  6248. gpm-p10-05  {//chby5 / p10-05 formula by Morgan L. Owens
  6249.              //Translated from .frm to .ufm
  6250.              //and slightly modified by Gedeon Peteri, April 1999
  6251. complex r;
  6252. parameter complex p1;
  6253. complex zz;
  6254. complex f;
  6255. parameter complex p2;
  6256. complex fd;
  6257. parameter complex p3;
  6258. complex oz;
  6259. parameter real bailout;
  6260.  
  6261.     void init(void)
  6262.     {
  6263.         z=fn4(pixel);
  6264.         r=p1;
  6265.     }
  6266.     void loop(void)
  6267.     {
  6268.         zz=z*z;
  6269.         f=p2*fn1((11*zz*(13*zz*(zz*(17*zz*(19*zz-45)+630)-210)+315)-63)/256);
  6270.         fd=p3*fn2(110*z*(13*zz*(zz*(17*zz*(19*zz-36)+378)-84)+63)/256);
  6271.         oz=z;
  6272.         z=z-fn3(r*f/fd);
  6273.     }
  6274.     bool bailout(void)
  6275.     {
  6276.         return(bailout<=|z-oz|);
  6277.     }
  6278.     void description(void)
  6279.     {
  6280.         this.title="gpm-p10-05";
  6281.  
  6282.         p1.caption="Parameter 1";
  6283.         p1.default=(1.0,1.0);
  6284.    
  6285.  
  6286.         p2.caption="Parameter 2";
  6287.         p2.default=(1.0,0.0);
  6288.    
  6289.  
  6290.         p3.caption="Parameter 3";
  6291.         p3.default=(1.0,0.0);
  6292.    
  6293.  
  6294.         bailout.caption="Bailout";
  6295.         bailout.default=0.005;
  6296.    
  6297.  
  6298.         fn1.caption="Function 1";
  6299.         fn1.default = "ident" ;
  6300.   
  6301.  
  6302.         fn2.caption="Function 2";
  6303.         fn2.default = "ident" ;
  6304.   
  6305.  
  6306.         fn3.caption="Function 3";
  6307.         fn3.default = "ident" ;
  6308.   
  6309.  
  6310.         fn4.caption="Function 4";
  6311.         fn4.default = "ident" ;
  6312.   
  6313.     }
  6314. }
  6315.  
  6316.  
  6317. gpm-s02-23  {//chby23 / s02-23 formula by Morgan L. Owens
  6318.              //Translated from .frm to .ufm
  6319.              //and slightly modified by Gedeon Peteri, March 1999
  6320. complex t;
  6321. parameter complex p1;
  6322. complex Var_x;
  6323. complex Var_y;
  6324. complex tx;
  6325. complex ty;
  6326. parameter real bailout;
  6327.  
  6328.     void init(void)
  6329.     {
  6330.         z=fn3(pixel);
  6331.         t=p1;
  6332.     }
  6333.     void loop(void)
  6334.     {
  6335.         Var_x=real(z);
  6336.         Var_y=imag(z);
  6337.         tx=fn1(Var_x*Var_x-1);
  6338.         ty=fn2(Var_y*Var_y-1);
  6339.         Var_x=Var_x-t*ty;
  6340.         Var_y=Var_y+t*tx;
  6341.         z=Var_x+fn4(Var_y);
  6342.     }
  6343.     bool bailout(void)
  6344.     {
  6345.         return(|z|<=bailout);
  6346.     }
  6347.     void description(void)
  6348.     {
  6349.         this.title="gpm-s02-23";
  6350.  
  6351.         p1.caption="Parameter";
  6352.         p1.default=(1.0,0.0);
  6353.    
  6354.  
  6355.         bailout.caption="Bailout";
  6356.         bailout.default=4.0;
  6357.    
  6358.  
  6359.         fn1.caption="Function 1";
  6360.         fn1.default = "ident" ;
  6361.   
  6362.  
  6363.         fn2.caption="Function 2";
  6364.         fn2.default = "ident" ;
  6365.   
  6366.  
  6367.         fn3.caption="Function 3";
  6368.         fn3.default = "ident" ;
  6369.   
  6370.  
  6371.         fn4.caption="Function 4";
  6372.         fn4.default = "flip" ;
  6373.   
  6374.     }
  6375. }
  6376.  
  6377.  
  6378. gpm-s03-01  {//chby1 / s03-01 formula by Morgan L. Owens
  6379.              //Translated from .frm to .ufm
  6380.              //and slightly modified by Gedeon Peteri, October 1999
  6381. complex t;
  6382. parameter complex p1;
  6383. complex Var_x;
  6384. complex Var_y;
  6385. complex tx;
  6386. complex ty;
  6387. parameter real bailout;
  6388.  
  6389.     void init(void)
  6390.     {
  6391.         z=fn3(pixel);
  6392.         t=p1;
  6393.     }
  6394.     void loop(void)
  6395.     {
  6396.         Var_x=real(z);
  6397.         Var_y=imag(z);
  6398.         tx=fn1(Var_x*(Var_x*Var_x-2));
  6399.         ty=fn2(Var_y*(Var_y*Var_y-2));
  6400.         Var_x=Var_x-t*ty;
  6401.         Var_y=Var_y+t*tx;
  6402.         z=Var_x+fn4(Var_y);
  6403.     }
  6404.     bool bailout(void)
  6405.     {
  6406.         return(|z|<=bailout);
  6407.     }
  6408.     void description(void)
  6409.     {
  6410.         this.title="gpm-s03-01";
  6411.  
  6412.         p1.caption="Parameter";
  6413.         p1.default=(1.0,0.0);
  6414.    
  6415.  
  6416.         bailout.caption="Bailout";
  6417.         bailout.default=4.0;
  6418.    
  6419.  
  6420.         fn1.caption="Function 1";
  6421.         fn1.default = "ident" ;
  6422.   
  6423.  
  6424.         fn2.caption="Function 2";
  6425.         fn2.default = "ident" ;
  6426.   
  6427.  
  6428.         fn3.caption="Function 3";
  6429.         fn3.default = "ident" ;
  6430.   
  6431.  
  6432.         fn4.caption="Function 4";
  6433.  
  6434.         fn4.default = "flip" ;
  6435.   
  6436.     }
  6437. }
  6438.  
  6439.  
  6440. gpm-s04-15  {//chby15 / s04-15 formula by Morgan L. Owens
  6441.              //Translated from .frm to .ufm
  6442.              //and slightly modified by Gedeon Peteri, April 1999
  6443. complex r;
  6444. parameter complex p1;
  6445. complex zz;
  6446. complex f;
  6447. complex fd;
  6448. complex oz;
  6449. parameter real bailout;
  6450.  
  6451.     void init(void)
  6452.     {
  6453.         z=fn4(pixel);
  6454.         r=p1;
  6455.     }
  6456.     void loop(void)
  6457.     {
  6458.         zz=z*z;
  6459.         f=fn1(zz*(zz-3)+1);
  6460.         fd=fn2(2*z*(2*zz-3));
  6461.         oz=z;
  6462.         z=z-fn3(r*f/fd);
  6463.     }
  6464.     bool bailout(void)
  6465.     {
  6466.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  6467.     }
  6468.     void description(void)
  6469.     {
  6470.         this.title="gpm-s04-15";
  6471.  
  6472.         p1.caption="Parameter";
  6473.         p1.default=(2.0,2.0);
  6474.    
  6475.  
  6476.         bailout.caption="Bailout";
  6477.         bailout.default=1.0;
  6478.    
  6479.  
  6480.         fn1.caption="Function 1";
  6481.         fn1.default = "ident" ;
  6482.   
  6483.  
  6484.         fn2.caption="Function 2";
  6485.         fn2.default = "ident" ;
  6486.   
  6487.  
  6488.         fn3.caption="Function 3";
  6489.         fn3.default = "ident" ;
  6490.   
  6491.  
  6492.         fn4.caption="Function 4";
  6493.         fn4.default = "ident" ;
  6494.   
  6495.     }
  6496. }
  6497.  
  6498.  
  6499. gpm-s05-01  {//chby1 / s05-01 formula by Morgan L. Owens
  6500.              //Translated from .frm to .ufm
  6501.              //and slightly modified by Gedeon Peteri, November 1999
  6502. complex t;
  6503. parameter complex p1;
  6504. complex Var_x;
  6505. complex Var_y;
  6506. complex xx;
  6507. complex yy;
  6508. complex tx;
  6509. parameter complex p2;
  6510. complex ty;
  6511. parameter complex p3;
  6512. parameter real bailout;
  6513.  
  6514.     void init(void)
  6515.     {
  6516.         z=fn4(pixel);
  6517.         t=p1;
  6518.     }
  6519.     void loop(void)
  6520.     {
  6521.         Var_x=real(z);
  6522.         Var_y=imag(z);
  6523.         xx=Var_x*Var_x;
  6524.         yy=Var_y*Var_y;
  6525.         tx=p2*fn1(Var_x*(xx*(xx-4)+3));
  6526.         ty=p3*fn2(Var_y*(yy*(yy-4)+3));
  6527.         Var_x=Var_x-t*ty;
  6528.         Var_y=Var_y+t*tx;
  6529.         z=Var_x+fn3(Var_y);
  6530.     }
  6531.     bool bailout(void)
  6532.     {
  6533.         return(|z|<=bailout);
  6534.     }
  6535.     void description(void)
  6536.     {
  6537.         this.title="gpm-s05-01";
  6538.  
  6539.         p1.caption="Parameter 1";
  6540.         p1.default=(1.0,0.0);
  6541.    
  6542.  
  6543.         p2.caption="Parameter 2";
  6544.         p2.default=(1.0,0.0);
  6545.    
  6546.  
  6547.         p3.caption="Parameter 3";
  6548.         p3.default=(1.0,0.0);
  6549.    
  6550.  
  6551.         bailout.caption="Bailout";
  6552.         bailout.default=4.0;
  6553.    
  6554.  
  6555.         fn1.caption="Function 1";
  6556.         fn1.default = "ident" ;
  6557.   
  6558.  
  6559.         fn2.caption="Function 2";
  6560.         fn2.default = "ident" ;
  6561.   
  6562.  
  6563.         fn3.caption="Function 3";
  6564.         fn3.default = "flip" ;
  6565.   
  6566.  
  6567.         fn4.caption="Function 4";
  6568.         fn4.default = "ident" ;
  6569.   
  6570.     }
  6571. }
  6572.  
  6573.  
  6574. gpm-s06-01  {//chby1 / s06-01 formula by Morgan L. Owens
  6575.              //Translated from .frm to .ufm
  6576.              //and slightly modified by Gedeon Peteri, March 1999
  6577. complex t;
  6578. parameter complex p1;
  6579. complex Var_x;
  6580. complex Var_y;
  6581. complex xx;
  6582. complex yy;
  6583. complex tx;
  6584. complex ty;
  6585. parameter real bailout;
  6586.  
  6587.     void init(void)
  6588.     {
  6589.         z=fn3(pixel);
  6590.         t=p1;
  6591.     }
  6592.     void loop(void)
  6593.     {
  6594.         Var_x=real(z);
  6595.         Var_y=imag(z);
  6596.         xx=Var_x*Var_x;
  6597.         yy=Var_y*Var_y;
  6598.         tx=fn1(xx*(xx*(xx-5)+6)-1);
  6599.         ty=fn2(yy*(yy*(yy-5)+6)-1);
  6600.         Var_x=Var_x-t*ty;
  6601.         Var_y=Var_y+t*tx;
  6602.         z=Var_x+fn4(Var_y);
  6603.     }
  6604.     bool bailout(void)
  6605.     {
  6606.         return(|z|<=bailout);
  6607.     }
  6608.     void description(void)
  6609.     {
  6610.         this.title="gpm-s06-01";
  6611.  
  6612.         p1.caption="Parameter";
  6613.         p1.default=(1.0,0.0);
  6614.    
  6615.  
  6616.         bailout.caption="Bailout";
  6617.         bailout.default=4.0;
  6618.    
  6619.  
  6620.         fn1.caption="Function 1";
  6621.         fn1.default = "ident" ;
  6622.   
  6623.  
  6624.         fn2.caption="Function 2";
  6625.         fn2.default = "ident" ;
  6626.   
  6627.  
  6628.         fn3.caption="Function 3";
  6629.         fn3.default = "ident" ;
  6630.   
  6631.  
  6632.         fn4.caption="Function 4";
  6633.         fn4.default = "flip" ;
  6634.   
  6635.     }
  6636. }
  6637.  
  6638.  
  6639. gpm-s07-08  {//chby8 / s07-08 formula by Morgan L. Owens
  6640.              //Translated from .frm to .ufm
  6641.              //and slightly modified by Gedeon Peteri, April 1999
  6642. complex t;
  6643. parameter complex p1;
  6644. complex Var_x;
  6645. complex Var_y;
  6646. complex xx;
  6647. complex yy;
  6648. complex tx;
  6649. parameter complex p2;
  6650. complex ty;
  6651. parameter complex p3;
  6652. parameter real bailout;
  6653.  
  6654.     void init(void)
  6655.     {
  6656.         z=fn3(pixel);
  6657.         t=p1;
  6658.     }
  6659.     void loop(void)
  6660.     {
  6661.         Var_x=real(z);
  6662.         Var_y=imag(z);
  6663.         xx=Var_x*Var_x;
  6664.         yy=Var_y*Var_y;
  6665.         tx=p2*fn1(Var_x*(xx*(xx*(xx-6)+10)-4));
  6666.         ty=p3*fn2(Var_y*(yy*(yy*(yy-6)+10)-4));
  6667.         Var_x=Var_x-t*ty;
  6668.         Var_y=Var_y+t*tx;
  6669.         z=Var_x+fn4(Var_y);
  6670.     }
  6671.     bool bailout(void)
  6672.     {
  6673.         return(|z|<=bailout);
  6674.     }
  6675.     void description(void)
  6676.     {
  6677.         this.title="gpm-s07-08";
  6678.  
  6679.         p1.caption="Parameter 1";
  6680.         p1.default=(1.0,0.0);
  6681.    
  6682.  
  6683.         p2.caption="Parameter 2";
  6684.         p2.default=(1.0,0.0);
  6685.    
  6686.  
  6687.         p3.caption="Parameter 3";
  6688.         p3.default=(1.0,0.0);
  6689.    
  6690.  
  6691.         bailout.caption="Bailout";
  6692.         bailout.default=4.0;
  6693.    
  6694.  
  6695.         fn1.caption="Function 1";
  6696.         fn1.default = "sin" ;
  6697.   
  6698.  
  6699.         fn2.caption="Function 2";
  6700.         fn2.default = "sin" ;
  6701.   
  6702.  
  6703.         fn3.caption="Function 3";
  6704.         fn3.default = "ident" ;
  6705.   
  6706.  
  6707.         fn4.caption="Function 4";
  6708.         fn4.default = "flip" ;
  6709.   
  6710.     }
  6711. }
  6712.  
  6713.  
  6714. gpm-sc02-29 {//chby29 / sc02-29 formula by Morgan L. Owens
  6715.              //Translated from .frm to .ufm
  6716.              //and slightly modified by Gedeon Peteri, March 1999
  6717. complex t;
  6718. parameter complex p1;
  6719. complex Var_x;
  6720. complex Var_y;
  6721. complex tx;
  6722. complex ty;
  6723. complex test;
  6724. parameter real bailout;
  6725.  
  6726.     void init(void)
  6727.     {
  6728.         z=fn3(pixel);
  6729.         t=p1;
  6730.     }
  6731.     void loop(void)
  6732.     {
  6733.         Var_x=real(z);
  6734.         Var_y=imag(z);
  6735.         tx=fn1(2/Var_x);
  6736.         ty=fn2(2/Var_y);
  6737.         Var_x=Var_x-t*ty;
  6738.         Var_y=Var_y+t*tx;
  6739.         z=Var_x+fn4(Var_y);
  6740.         test=(|tx|+|ty|);
  6741.     }
  6742.     bool bailout(void)
  6743.     {
  6744.         return(test>=bailout && test<=1e30);
  6745.     }
  6746.     void description(void)
  6747.     {
  6748.         this.title="gpm-sc02-29";
  6749.  
  6750.         p1.caption="Parameter";
  6751.         p1.default=(0.5,0.0);
  6752.    
  6753.  
  6754.         bailout.caption="Bailout";
  6755.         bailout.default=4.0;
  6756.    
  6757.  
  6758.         fn1.caption="Function 1";
  6759.         fn1.default = "ident" ;
  6760.   
  6761.  
  6762.         fn2.caption="Function 2";
  6763.         fn2.default = "ident" ;
  6764.   
  6765.  
  6766.         fn3.caption="Function 3";
  6767.         fn3.default = "ident" ;
  6768.   
  6769.  
  6770.         fn4.caption="Function 4";
  6771.         fn4.default = "flip" ;
  6772.   
  6773.     }
  6774. }
  6775.  
  6776.  
  6777. gpm-t03-25 {//chby25 / t03-25 formula by Morgan L. Owens
  6778.             //Translated from .frm to .ufm
  6779.             //and slightly modified by Gedeon Peteri, March 1999
  6780. complex t;
  6781. parameter complex p1;
  6782. complex Var_x;
  6783. complex Var_y;
  6784. parameter real bailout;
  6785.  
  6786.     void init(void)
  6787.     {
  6788.         z=fn3(pixel);
  6789.         t=p1;
  6790.     }
  6791.     void loop(void)
  6792.     {
  6793.         Var_x=real(z);
  6794.         Var_y=imag(z);
  6795.         Var_y=Var_y+t*(fn1(Var_x*(4*Var_x*Var_x-3)));
  6796.         Var_x=Var_x-t*(fn2(Var_y*(4*Var_y*Var_y-3)));
  6797.         z=Var_x+fn4(Var_y);
  6798.     }
  6799.     bool bailout(void)
  6800.     {
  6801.         return(|z|<=bailout);
  6802.     }
  6803.     void description(void)
  6804.     {
  6805.         this.title="gpm-t03-25";
  6806.  
  6807.         p1.caption="Parameter";
  6808.         p1.default=(1.0,0.0);
  6809.    
  6810.  
  6811.         bailout.caption="Bailout";
  6812.         bailout.default=4.0;
  6813.    
  6814.  
  6815.         fn1.caption="Function 1";
  6816.         fn1.default = "sin" ;
  6817.   
  6818.  
  6819.         fn2.caption="Function 2";
  6820.         fn2.default = "sin" ;
  6821.   
  6822.  
  6823.         fn3.caption="Function 3";
  6824.         fn3.default = "ident" ;
  6825.   
  6826.  
  6827.         fn4.caption="Function 4";
  6828.         fn4.default = "flip" ;
  6829.   
  6830.     }
  6831. }
  6832.  
  6833.  
  6834. gpm-t07-01  {//chby1 / t07-01 formula by Morgan L. Owens
  6835.              //Translated from .frm to .ufm
  6836.              //and slightly modified by Gedeon Peteri, April 1999
  6837. complex t;
  6838. parameter complex p1;
  6839. complex Var_x;
  6840. complex Var_y;
  6841. complex xx;
  6842. complex yy;
  6843. complex tx;
  6844. parameter complex p2;
  6845. complex ty;
  6846. parameter complex p3;
  6847. parameter real bailout;
  6848.  
  6849.     void init(void)
  6850.     {
  6851.         z=fn4(pixel);
  6852.         t=p1;
  6853.     }
  6854.     void loop(void)
  6855.     {
  6856.         Var_x=real(z);
  6857.         Var_y=imag(z);
  6858.         xx=Var_x*Var_x;
  6859.         yy=Var_y*Var_y;
  6860.         tx=p2*fn1(Var_x*(8*xx*((xx+xx)*(4*xx-7)+7)-7));
  6861.         ty=p3*fn2(Var_y*(8*yy*((yy+yy)*(4*yy-7)+7)-7));
  6862.         Var_x=Var_x-t*ty;
  6863.         Var_y=Var_y+t*tx;
  6864.         z=Var_x+fn3(Var_y);
  6865.     }
  6866.     bool bailout(void)
  6867.     {
  6868.         return(|z|<=bailout);
  6869.     }
  6870.     void description(void)
  6871.     {
  6872.         this.title="gpm-t07-01";
  6873.  
  6874.         p1.caption="Parameter 1";
  6875.         p1.default=(0.5,0.0);
  6876.    
  6877.  
  6878.         p2.caption="Parameter 2";
  6879.         p2.default=(1.0,0.0);
  6880.    
  6881.  
  6882.         p3.caption="Parameter 3";
  6883.         p3.default=(1.0,0.0);
  6884.    
  6885.  
  6886.         bailout.caption="Bailout";
  6887.         bailout.default=4.0;
  6888.    
  6889.  
  6890.         fn1.caption="Function 1";
  6891.         fn1.default = "ident" ;
  6892.   
  6893.  
  6894.         fn2.caption="Function 2";
  6895.         fn2.default = "ident" ;
  6896.   
  6897.  
  6898.         fn3.caption="Function 3";
  6899.         fn3.default = "flip" ;
  6900.   
  6901.  
  6902.         fn4.caption="Function 4";
  6903.         fn4.default = "ident" ;
  6904.   
  6905.     }
  6906. }
  6907.  
  6908.  
  6909. gpm-t08-11  {//chby11 / t08-11 formula by Morgan L. Owens
  6910.              //Translated from .frm to .ufm
  6911.              //and slightly modified by Gedeon Peteri, April 1999
  6912. complex c;
  6913. parameter complex p1;
  6914. complex d;
  6915. parameter complex p2;
  6916. complex zz;
  6917. parameter real bailout;
  6918.  
  6919.     void init(void)
  6920.     {
  6921.         z=fn2(pixel);
  6922.         c=p1;
  6923.         d=p2;
  6924.     }
  6925.     void loop(void)
  6926.     {
  6927.         zz=z*z;
  6928.         z=d*fn1((32*zz*(zz*(4*zz*(zz-2)+5)-1)+1)*c);
  6929.     }
  6930.     bool bailout(void)
  6931.     {
  6932.         return(|z|<=bailout);
  6933.     }
  6934.     void description(void)
  6935.     {
  6936.         this.title="gpm-t08-11";
  6937.  
  6938.         p1.caption="Parameter 1";
  6939.         p1.default=(0.05,0.05);
  6940.    
  6941.  
  6942.         p2.caption="Parameter 2";
  6943.         p2.default=(1.0,1.0);
  6944.    
  6945.  
  6946.         bailout.caption="Bailout";
  6947.         bailout.default=100.0;
  6948.    
  6949.  
  6950.         fn1.caption="Function 1";
  6951.         fn1.default = "ident" ;
  6952.   
  6953.  
  6954.         fn2.caption="Function 2";
  6955.         fn2.default = "ident" ;
  6956.   
  6957.     }
  6958. }
  6959.  
  6960.  
  6961. gpm-t08-15 {//chby15 / t08-15 formula by Morgan L. Owens
  6962.             //Translated from .frm to .ufm
  6963.             //and slightly modified by Gedeon Peteri, March 1999
  6964. complex r;
  6965. parameter complex p1;
  6966. complex zz;
  6967. complex a;
  6968. complex b;
  6969. complex f;
  6970. parameter complex p2;
  6971. complex fd;
  6972. parameter complex p3;
  6973. complex oz;
  6974. parameter real bailout;
  6975.  
  6976.     void init(void)
  6977.     {
  6978.         z=fn3(pixel);
  6979.         r=p1;
  6980.     }
  6981.     void loop(void)
  6982.     {
  6983.         zz=z*z;
  6984.         a=2*zz;
  6985.         b=4*zz;
  6986.         f=p2*(fn1(32*zz*(zz*(b*(zz-2)+5)-1)+1));
  6987.         fd=p3*(fn2(64*z*(a*(b*(a-3)+5)-1)));
  6988.         oz=z;
  6989.         z=z-r*f/fd;
  6990.     }
  6991.     bool bailout(void)
  6992.     {
  6993.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  6994.     }
  6995.     void description(void)
  6996.     {
  6997.         this.title="gpm-t08-15";
  6998.  
  6999.         p1.caption="Parameter 1";
  7000.         p1.default=(6.0,2.0);
  7001.    
  7002.  
  7003.         p2.caption="Parameter 2";
  7004.         p2.default=(2.0,0.0);
  7005.    
  7006.  
  7007.         p3.caption="Parameter 3";
  7008.         p3.default=(1.0,0.0);
  7009.    
  7010.  
  7011.         bailout.caption="Bailout";
  7012.         bailout.default=1.0;
  7013.    
  7014.  
  7015.         fn1.caption="Function 1";
  7016.         fn1.default = "ident" ;
  7017.   
  7018.  
  7019.         fn2.caption="Function 2";
  7020.         fn2.default = "ident" ;
  7021.   
  7022.  
  7023.         fn3.caption="Function 3";
  7024.         fn3.default = "ident" ;
  7025.   
  7026.     }
  7027. }
  7028.  
  7029.  
  7030. gpm-t08-20 {//chby20 / t08-20 formula by Morgan L. Owens
  7031.             //Translated from .frm to .ufm
  7032.             //and slightly modified by Gedeon Peteri, March 1999
  7033. complex t;
  7034. parameter complex p1;
  7035. complex Var_x;
  7036. complex Var_y;
  7037. complex xx;
  7038. complex yy;
  7039. parameter real bailout;
  7040.  
  7041.     void init(void)
  7042.     {
  7043.         z=fn3(pixel);
  7044.         t=p1;
  7045.     }
  7046.     void loop(void)
  7047.     {
  7048.         Var_x=real(z);
  7049.         Var_y=imag(z);
  7050.         xx=Var_x*Var_x;
  7051.         yy=Var_y*Var_y;
  7052.         Var_y=Var_y+t*(fn1(32*xx*(xx*(4*xx*(xx-2)+5)-1)+1));
  7053.         Var_x=Var_x-t*(fn2(32*yy*(yy*(4*yy*(yy-2)+5)-1)+1));
  7054.         z=Var_x+fn4(Var_y);
  7055.     }
  7056.     bool bailout(void)
  7057.     {
  7058.         return(|z|<=bailout);
  7059.     }
  7060.     void description(void)
  7061.     {
  7062.         this.title="gpm-t08-20";
  7063.  
  7064.         p1.caption="Parameter";
  7065.         p1.default=(1.0,0.0);
  7066.    
  7067.  
  7068.         bailout.caption="Bailout";
  7069.         bailout.default=4.0;
  7070.    
  7071.  
  7072.         fn1.caption="Function 1";
  7073.         fn1.default = "sin" ;
  7074.   
  7075.  
  7076.         fn2.caption="Function 2";
  7077.         fn2.default = "sin" ;
  7078.   
  7079.  
  7080.         fn3.caption="Function 3";
  7081.         fn3.default = "ident" ;
  7082.   
  7083.  
  7084.         fn4.caption="Function 4";
  7085.         fn4.default = "flip" ;
  7086.   
  7087.     }
  7088. }
  7089.  
  7090.  
  7091. gpm-u03-01 {//chby1 / u03-01 formula by Morgan L. Owens
  7092.             //Translated from .frm to .ufm
  7093.             //and slightly modified by Gedeon Peteri, March 1999
  7094. complex t;
  7095. parameter complex p1;
  7096. complex Var_x;
  7097. complex Var_y;
  7098. complex tx;
  7099. complex ty;
  7100. parameter real bailout;
  7101.  
  7102.     void init(void)
  7103.     {
  7104.         z=fn3(pixel);
  7105.         t=p1;
  7106.     }
  7107.     void loop(void)
  7108.     {
  7109.         Var_x=real(z);
  7110.         Var_y=imag(z);
  7111.         tx=fn1(4*Var_x*((Var_x+Var_x)*Var_x-1));
  7112.         ty=fn2(4*Var_y*((Var_y+Var_y)*Var_y-1));
  7113.         Var_x=Var_x-t*ty;
  7114.         Var_y=Var_y+t*tx;
  7115.         z=Var_x+fn4(Var_y);
  7116.     }
  7117.     bool bailout(void)
  7118.     {
  7119.         return(|z|<=bailout);
  7120.     }
  7121.     void description(void)
  7122.     {
  7123.         this.title="gpm-u03-01";
  7124.  
  7125.         p1.caption="Parameter";
  7126.         p1.default=(0.5,0.0);
  7127.    
  7128.  
  7129.         bailout.caption="Bailout";
  7130.         bailout.default=4.0;
  7131.    
  7132.  
  7133.         fn1.caption="Function 1";
  7134.         fn1.default = "ident" ;
  7135.   
  7136.  
  7137.         fn2.caption="Function 2";
  7138.         fn2.default = "ident" ;
  7139.   
  7140.  
  7141.         fn3.caption="Function 3";
  7142.         fn3.default = "ident" ;
  7143.   
  7144.  
  7145.         fn4.caption="Function 4";
  7146.         fn4.default = "flip" ;
  7147.   
  7148.     }
  7149. }
  7150.  
  7151.  
  7152. gpm-u04-01 {//chby1 / u04-01 formula by Morgan L. Owens
  7153.             //Translated from .frm to .ufm
  7154.             //and slightly modified by Gedeon Peteri, March 1999
  7155. complex t;
  7156. parameter complex p1;
  7157. complex Var_x;
  7158. complex Var_y;
  7159. complex ax;
  7160. complex ay;
  7161. complex tx;
  7162. parameter complex p2;
  7163. complex ty;
  7164. parameter complex p3;
  7165. parameter real bailout;
  7166.  
  7167.     void init(void)
  7168.     {
  7169.         z=fn4(pixel);
  7170.         t=p1;
  7171.     }
  7172.     void loop(void)
  7173.     {
  7174.         Var_x=real(z);
  7175.         Var_y=imag(z);
  7176.         ax=4*Var_x*Var_x;
  7177.         ay=4*Var_y*Var_y;
  7178.         tx=p2*fn1(ax*(ax-3)+1);
  7179.         ty=p3*fn2(ay*(ay-3)+1);
  7180.         Var_x=Var_x-t*ty;
  7181.         Var_y=Var_y+t*tx;
  7182.         z=Var_x+fn3(Var_y);
  7183.     }
  7184.     bool bailout(void)
  7185.     {
  7186.         return(|z|<=bailout);
  7187.     }
  7188.     void description(void)
  7189.     {
  7190.         this.title="gpm-u04-01";
  7191.  
  7192.         p1.caption="Parameter 1";
  7193.         p1.default=(0.2,0.0);
  7194.    
  7195.  
  7196.         p2.caption="Parameter 2";
  7197.         p2.default=(1.0,0.0);
  7198.    
  7199.  
  7200.         p3.caption="Parameter 3";
  7201.         p3.default=(1.0,0.0);
  7202.    
  7203.  
  7204.         bailout.caption="Bailout";
  7205.         bailout.default=4.0;
  7206.    
  7207.  
  7208.         fn1.caption="Function 1";
  7209.         fn1.default = "ident" ;
  7210.   
  7211.  
  7212.         fn2.caption="Function 2";
  7213.         fn2.default = "ident" ;
  7214.   
  7215.  
  7216.         fn3.caption="Function 3";
  7217.         fn3.default = "flip" ;
  7218.   
  7219.  
  7220.         fn4.caption="Function 4";
  7221.         fn4.default = "ident" ;
  7222.   
  7223.     }
  7224. }
  7225.  
  7226.  
  7227. gpm-u08-15 {//chby15 / u08-15 formula by Morgan L. Owens
  7228.             //Translated from .frm to .ufm
  7229.             //and slightly modified by Gedeon Peteri, March 1999
  7230. complex r;
  7231. parameter complex p1;
  7232. complex zz;
  7233. complex a;
  7234. complex b;
  7235. complex f;
  7236. parameter complex p2;
  7237. complex fd;
  7238. parameter complex p3;
  7239. complex oz;
  7240. parameter real bailout;
  7241.  
  7242.     void init(void)
  7243.     {
  7244.         z=fn3(pixel);
  7245.         r=p1;
  7246.     }
  7247.     void loop(void)
  7248.     {
  7249.         zz=z*z;
  7250.         a=4*zz;
  7251.         b=2*zz;
  7252.         f=fn1(p2*(8*zz*(b*(a*(a-7)+15)-5)+1));
  7253.         fd=fn2(p3*(16*z*(4*zz*(b*(16*zz-21)+15)-5)));
  7254.         oz=z;
  7255.         z=z-r*f/fd;
  7256.     }
  7257.     bool bailout(void)
  7258.     {
  7259.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  7260.     }
  7261.     void description(void)
  7262.     {
  7263.         this.title="gpm-u08-15";
  7264.  
  7265.         p1.caption="Parameter 1";
  7266.         p1.default=(0.2,0.0);
  7267.    
  7268.  
  7269.         p2.caption="Parameter 2";
  7270.         p2.default=(0.2,0.0);
  7271.    
  7272.  
  7273.         p3.caption="Parameter 3";
  7274.         p3.default=(0.2,0.0);
  7275.    
  7276.  
  7277.         bailout.caption="Bailout";
  7278.         bailout.default=1.0;
  7279.    
  7280.  
  7281.         fn1.caption="Function 1";
  7282.         fn1.default = "ident" ;
  7283.   
  7284.  
  7285.         fn2.caption="Function 2";
  7286.         fn2.default = "ident" ;
  7287.   
  7288.  
  7289.         fn3.caption="Function 3";
  7290.         fn3.default = "ident" ;
  7291.   
  7292.     }
  7293. }
  7294.  
  7295.  
  7296. gpm-u10-05  {//chby5 / u10-05 formula by Morgan L. Owens
  7297.              //Translated from .frm to .ufm
  7298.              //and slightly modified by Gedeon Peteri, November 1999
  7299. complex r;
  7300. parameter complex p1;
  7301. complex zz;
  7302. complex a;
  7303. complex b;
  7304. complex f;
  7305. parameter complex p2;
  7306. complex fd;
  7307. parameter complex p3;
  7308. complex oz;
  7309. parameter real bailout;
  7310.  
  7311.     void init(void)
  7312.     {
  7313.         z=fn4(pixel);
  7314.         r=p1;
  7315.     }
  7316.     void loop(void)
  7317.     {
  7318.         zz=z*z;
  7319.         a=4*zz;
  7320.         b=16*zz;
  7321.         f=p2*fn1(a*(a*(b*(zz*(a-9)+6)-35)+7)-1);
  7322.         fd=p3*fn2(8*z*(8*zz*(b*(2*zz*(5*zz-9)+9)-35)+7));
  7323.         oz=z;
  7324.         z=fn3(z-r*f/fd);
  7325.     }
  7326.     bool bailout(void)
  7327.     {
  7328.         return(bailout<=|z-oz|);
  7329.     }
  7330.     void description(void)
  7331.     {
  7332.         this.title="gpm-u10-05";
  7333.  
  7334.         p1.caption="Parameter 1";
  7335.         p1.default=(1.0,-2.0);
  7336.    
  7337.  
  7338.         p2.caption="Parameter 2";
  7339.         p2.default=(2.0,0.0);
  7340.    
  7341.  
  7342.         p3.caption="Parameter 3";
  7343.         p3.default=(0.5,0.0);
  7344.    
  7345.  
  7346.         bailout.caption="Bailout";
  7347.         bailout.default=1.0;
  7348.    
  7349.  
  7350.         fn1.caption="Function 1";
  7351.         fn1.default = "ident" ;
  7352.   
  7353.  
  7354.         fn2.caption="Function 2";
  7355.         fn2.default = "ident" ;
  7356.   
  7357.  
  7358.         fn3.caption="Function 3";
  7359.         fn3.default = "ident" ;
  7360.   
  7361.  
  7362.         fn4.caption="Function 4";
  7363.         fn4.default = "ident" ;
  7364.   
  7365.     }
  7366. }
  7367.  
  7368.  
  7369. gpm-uc07-15{//chby15 / uc07-15 formula by Morgan L. Owens
  7370.             //Translated from .frm to .ufm
  7371.             //and slightly modified by Gedeon Peteri, March 1999
  7372. complex r;
  7373. parameter complex p1;
  7374. complex a;
  7375. complex aa;
  7376. complex f;
  7377. complex fd;
  7378. complex oz;
  7379. parameter real bailout;
  7380.  
  7381.     void init(void)
  7382.     {
  7383.         z=fn2(pixel);
  7384.         r=p1;
  7385.     }
  7386.     void loop(void)
  7387.     {
  7388.         a=4*z-2;
  7389.         aa=a*a;
  7390.         f=(a*(aa*(aa*(aa-6)+10)-4));
  7391.         fd=(4*(aa*(aa*(7*aa-30)+30)-4));
  7392.         oz=z;
  7393.         z=fn1(z-r*f/fd);
  7394.     }
  7395.     bool bailout(void)
  7396.     {
  7397.         return(bailout<=sqrt(|(|z|)-(|oz|)|));
  7398.     }
  7399.     void description(void)
  7400.     {
  7401.         this.title="gpm-uc07-15";
  7402.  
  7403.         p1.caption="Parameter";
  7404.         p1.default=(6.0,-4.0);
  7405.    
  7406.  
  7407.         bailout.caption="Bailout";
  7408.         bailout.default=0.05;
  7409.    
  7410.  
  7411.         fn1.caption="Function 1";
  7412.         fn1.default = "ident" ;
  7413.   
  7414.  
  7415.         fn2.caption="Function 2";
  7416.         fn2.default = "ident" ;
  7417.   
  7418.     }
  7419. }
  7420.  
  7421.  
  7422. comment
  7423. {
  7424. ;The source of the functions on which
  7425. ;these formulas are based is the book entitled
  7426. ;Fractal Cosmos -- The Art of Mathematical Design
  7427. ;(Lifesmith) by Jeff Berkowitz.
  7428. ;Compiled by Gedeon Peteri, 1999)
  7429.  
  7430.  
  7431. }
  7432.  
  7433. gp-frc-01  {//f(z)=sgrt(z^4+1)+c
  7434.             //e.g.: page 3/27, top right
  7435. parameter complex p1;
  7436. parameter complex p2;
  7437. parameter complex p3;
  7438. parameter int test;
  7439. parameter real bailout;
  7440.  
  7441.     void init(void)
  7442.     {
  7443.         z=fn1(pixel);
  7444.     }
  7445.     void loop(void)
  7446.     {
  7447.         z=fn2((z^p1+1)^p2+p3);
  7448.     }
  7449.     bool bailout(void)
  7450.     {
  7451.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7452.     }
  7453.     void description(void)
  7454.     {
  7455.         this.title="gfp-frc-01";
  7456.  
  7457.         p1.caption="Exponent 1";
  7458.         p1.default=(4.0,0.0);
  7459.    
  7460.  
  7461.         p2.caption="Exponent 2";
  7462.         p2.default=(0.5,0.0);
  7463.    
  7464.  
  7465.         p3.caption="Julia seed";
  7466.         p3.default=(-0.275,0.47);
  7467.    
  7468.  
  7469.         bailout.caption="Bailout Value";
  7470.         bailout.default=64.0;
  7471.    
  7472.  
  7473.         test.caption = "Bailout Test";
  7474.         test.default = 0;
  7475.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7476.    
  7477.  
  7478.         fn1.caption="Function 1";
  7479.         fn1.default = "ident" ;
  7480.   
  7481.  
  7482.         fn2.caption="Function 2";
  7483.         fn2.default = "ident" ;
  7484.   
  7485.     }
  7486. }
  7487.  
  7488.  
  7489. gp-frc-02  {//f(z)=sgrt(z^4+c)
  7490.             //e.g.: page 3/27, bottom right
  7491. parameter complex p1;
  7492. parameter complex p3;
  7493. parameter complex p2;
  7494. parameter int test;
  7495. parameter real bailout;
  7496.  
  7497.     void init(void)
  7498.     {
  7499.         z=fn1(pixel);
  7500.     }
  7501.     void loop(void)
  7502.     {
  7503.         z=fn2((z^p1+p3)^p2);
  7504.     }
  7505.     bool bailout(void)
  7506.     {
  7507.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7508.     }
  7509.     void description(void)
  7510.     {
  7511.         this.title="gfp-frc-02";
  7512.  
  7513.         p1.caption="Exponent 1";
  7514.         p1.default=(4.0,0.0);
  7515.    
  7516.  
  7517.         p2.caption="Exponent 2";
  7518.         p2.default=(0.5,0.0);
  7519.    
  7520.  
  7521.         p3.caption="Julia seed";
  7522.         p3.default=(0.19,-0.67);
  7523.    
  7524.  
  7525.         bailout.caption="Bailout Value";
  7526.         bailout.default=64.0;
  7527.    
  7528.  
  7529.         test.caption = "Bailout Test";
  7530.         test.default = 0;
  7531.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7532.    
  7533.  
  7534.         fn1.caption="Function 1";
  7535.         fn1.default = "ident" ;
  7536.   
  7537.  
  7538.         fn2.caption="Function 2";
  7539.         fn2.default = "ident" ;
  7540.   
  7541.     }
  7542. }
  7543.  
  7544.  
  7545. gp-frc-03  {//f(z)=(z^2+c)^2+z+c
  7546.             //e.g.: page 3/29, bottom left
  7547. parameter complex p1;
  7548. parameter complex p3;
  7549. parameter complex p2;
  7550. parameter int test;
  7551. parameter real bailout;
  7552.  
  7553.     void init(void)
  7554.     {
  7555.         z=fn1(pixel);
  7556.     }
  7557.     void loop(void)
  7558.     {
  7559.         z=fn2((z^p1+p3)^p2+z+p3);
  7560.     }
  7561.     bool bailout(void)
  7562.     {
  7563.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7564.     }
  7565.     void description(void)
  7566.     {
  7567.         this.title="gfp-frc-03";
  7568.  
  7569.         p1.caption="Exponent 1";
  7570.         p1.default=(2.0,0.0);
  7571.    
  7572.  
  7573.         p2.caption="Exponent 2";
  7574.         p2.default=(2,0.0);
  7575.    
  7576.  
  7577.         p3.caption="Julia seed";
  7578.         p3.default=(-0.27,0.46);
  7579.    
  7580.  
  7581.         bailout.caption="Bailout Value";
  7582.         bailout.default=64.0;
  7583.    
  7584.  
  7585.         test.caption = "Bailout Test";
  7586.         test.default = 0;
  7587.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7588.    
  7589.  
  7590.         fn1.caption="Function 1";
  7591.         fn1.default = "ident" ;
  7592.   
  7593.  
  7594.         fn2.caption="Function 2";
  7595.         fn2.default = "ident" ;
  7596.   
  7597.     }
  7598. }
  7599.  
  7600.  
  7601. gp-frc-04  {//f(z)=(z^2+c+1)/(z^2-c-1)
  7602.             //e.g.: page 3/24, bottom left
  7603. parameter complex p1;
  7604. parameter complex p3;
  7605. parameter complex p2;
  7606. parameter int test;
  7607. parameter real bailout;
  7608.  
  7609.     void init(void)
  7610.     {
  7611.         z=fn1(pixel);
  7612.     }
  7613.     void loop(void)
  7614.     {
  7615.         z=fn2((z^p1+p3+1)/(z^p2-p3-1));
  7616.     }
  7617.     bool bailout(void)
  7618.     {
  7619.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7620.     }
  7621.     void description(void)
  7622.     {
  7623.         this.title="gfp-frc-04";
  7624.  
  7625.         p1.caption="Exponent 1";
  7626.         p1.default=(2.0,0.0);
  7627.    
  7628.  
  7629.         p2.caption="Exponent 2";
  7630.         p2.default=(2,0.0);
  7631.    
  7632.  
  7633.         p3.caption="Julia seed";
  7634.         p3.default=(0.25,-0.5);
  7635.    
  7636.  
  7637.         bailout.caption="Bailout Value";
  7638.         bailout.default=64.0;
  7639.    
  7640.  
  7641.         test.caption = "Bailout Test";
  7642.         test.default = 0;
  7643.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7644.    
  7645.  
  7646.         fn1.caption="Function 1";
  7647.         fn1.default = "ident" ;
  7648.   
  7649.  
  7650.         fn2.caption="Function 2";
  7651.         fn2.default = "ident" ;
  7652.   
  7653.     }
  7654. }
  7655.  
  7656.  
  7657. comment
  7658. {
  7659. ;The following formulas are translations, modifications, and
  7660. ;embellishments of fractint formulas in file newtchb2.frm
  7661.  
  7662.  
  7663. }
  7664.  
  7665. gpm-jlag2   {//Translation and modification of J_Laguenew2
  7666.              //from newtchb2.frm
  7667.              //by Gedeon Peteri, October 1999
  7668. complex c;
  7669. parameter complex p1;
  7670. parameter complex p2;
  7671. parameter int test;
  7672. parameter real bailout;
  7673.  
  7674.     void init(void)
  7675.     {
  7676.         z=fn2(pixel);
  7677.         c=p1;
  7678.     }
  7679.     void loop(void)
  7680.     {
  7681.         z=fn1(p2*((z*(z-4)+2)/2+c));
  7682.     }
  7683.     bool bailout(void)
  7684.     {
  7685.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7686.     }
  7687.     void description(void)
  7688.     {
  7689.         this.title="gpm-jlag2";
  7690.  
  7691.         p1.caption="Parameter 1";
  7692.         p1.default=(1.0,0.0);
  7693.    
  7694.  
  7695.         p2.caption="Parameter 2";
  7696.         p2.default=(1.0,0.0);
  7697.    
  7698.  
  7699.         bailout.caption="Bailout value";
  7700.         bailout.default=100.0;
  7701.    
  7702.  
  7703.         test.caption = "Bailout test";
  7704.         test.default = 0;
  7705.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7706.         test.hint = "Original formula uses mod by default.";
  7707.    
  7708.  
  7709.         fn1.caption="Function 1";
  7710.         fn1.default = "ident" ;
  7711.   
  7712.  
  7713.         fn2.caption="Function 2";
  7714.         fn2.default = "ident" ;
  7715.   
  7716.     }
  7717. }
  7718.  
  7719.  
  7720. gpm-jlag3   {//Translation and modification of J_Laguenew3
  7721.              //from newtchb2.frm
  7722.              //by Gedeon Peteri, October 1999
  7723. complex c;
  7724. parameter complex p1;
  7725. parameter complex p2;
  7726. parameter int test;
  7727. parameter real bailout;
  7728.  
  7729.     void init(void)
  7730.     {
  7731.         z=fn2(pixel);
  7732.         c=p1;
  7733.     }
  7734.     void loop(void)
  7735.     {
  7736.         z=fn1(p2*((z*(z*(-z+9)-18)+6)/6+c));
  7737.     }
  7738.     bool bailout(void)
  7739.     {
  7740.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7741.     }
  7742.     void description(void)
  7743.     {
  7744.         this.title="gpm-jlag3";
  7745.  
  7746.         p1.caption="Parameter 1";
  7747.         p1.default=(1.0,0.0);
  7748.    
  7749.  
  7750.         p2.caption="Parameter 2";
  7751.         p2.default=(1.0,0.0);
  7752.    
  7753.  
  7754.         bailout.caption="Bailout value";
  7755.         bailout.default=100.0;
  7756.    
  7757.  
  7758.         test.caption = "Bailout test";
  7759.         test.default = 0;
  7760.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7761.         test.hint = "Original formula uses mod by default.";
  7762.    
  7763.  
  7764.         fn1.caption="Function 1";
  7765.         fn1.default = "ident" ;
  7766.   
  7767.  
  7768.         fn2.caption="Function 2";
  7769.         fn2.default = "ident" ;
  7770.   
  7771.     }
  7772. }
  7773.  
  7774.  
  7775. gpm-jlag4   {//Translation and modification of J_Laguenew4
  7776.              //from newtchb2.frm
  7777.              //by Gedeon Peteri, October 1999
  7778. complex c;
  7779. parameter complex p1;
  7780. parameter complex p2;
  7781. parameter int test;
  7782. parameter real bailout;
  7783.  
  7784.     void init(void)
  7785.     {
  7786.         z=fn2(pixel);
  7787.         c=p1;
  7788.     }
  7789.     void loop(void)
  7790.     {
  7791.         z=fn1(p2*((z*(z*(z*(z-16)+72)-96)+24)/24+c));
  7792.     }
  7793.     bool bailout(void)
  7794.     {
  7795.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7796.     }
  7797.     void description(void)
  7798.     {
  7799.         this.title="gpm-jlag4";
  7800.  
  7801.         p1.caption="Parameter 1";
  7802.         p1.default=(1.0,0.0);
  7803.    
  7804.  
  7805.         p2.caption="Parameter 2";
  7806.         p2.default=(1.0,0.0);
  7807.    
  7808.  
  7809.         bailout.caption="Bailout value";
  7810.         bailout.default=100.0;
  7811.    
  7812.  
  7813.         test.caption = "Bailout test";
  7814.         test.default = 0;
  7815.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7816.         test.hint = "Original formula uses mod by default.";
  7817.    
  7818.  
  7819.         fn1.caption="Function 1";
  7820.         fn1.default = "ident" ;
  7821.   
  7822.  
  7823.         fn2.caption="Function 2";
  7824.         fn2.default = "ident" ;
  7825.   
  7826.     }
  7827. }
  7828.  
  7829.  
  7830. gpm-jlag5   {//Translation and modification of J_Laguenew5
  7831.              //from newtchb2.frm
  7832.              //by Gedeon Peteri, October 1999
  7833. complex c;
  7834. parameter complex p1;
  7835. parameter complex p2;
  7836. parameter int test;
  7837. parameter real bailout;
  7838.  
  7839.     void init(void)
  7840.     {
  7841.         z=fn2(pixel);
  7842.         c=p1;
  7843.     }
  7844.     void loop(void)
  7845.     {
  7846.         z=fn1(p2*((z*(z*(z*(z*(-z+25)-200)+600)-600)+120)/120+c));
  7847.     }
  7848.     bool bailout(void)
  7849.     {
  7850.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7851.     }
  7852.     void description(void)
  7853.     {
  7854.         this.title="gpm-jlag5";
  7855.  
  7856.         p1.caption="Parameter 1";
  7857.         p1.default=(1.0,0.0);
  7858.    
  7859.  
  7860.         p2.caption="Parameter 2";
  7861.         p2.default=(1.0,0.0);
  7862.    
  7863.  
  7864.         bailout.caption="Bailout value";
  7865.         bailout.default=100.0;
  7866.    
  7867.  
  7868.         test.caption = "Bailout test";
  7869.         test.default = 0;
  7870.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7871.         test.hint = "Original formula uses mod by default.";
  7872.    
  7873.  
  7874.         fn1.caption="Function 1";
  7875.         fn1.default = "ident" ;
  7876.   
  7877.  
  7878.         fn2.caption="Function 2";
  7879.         fn2.default = "ident" ;
  7880.   
  7881.     }
  7882. }
  7883.  
  7884.  
  7885. gpm-jlag6   {//Translation and modification of J_Laguenew6
  7886.              //from newtchb2.frm
  7887.              //by Gedeon Peteri, October 1999
  7888. complex c;
  7889. parameter complex p1;
  7890. parameter complex p2;
  7891. parameter int test;
  7892. parameter real bailout;
  7893.  
  7894.     void init(void)
  7895.     {
  7896.         z=fn2(pixel);
  7897.         c=p1;
  7898.     }
  7899.     void loop(void)
  7900.     {
  7901.         z=fn1(p2*((z*(z*(z*(z*(z*(z-36)+450)-2400)+5400)-4320)+720)/720+c));
  7902.     }
  7903.     bool bailout(void)
  7904.     {
  7905.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7906.     }
  7907.     void description(void)
  7908.     {
  7909.         this.title="gpm-jlag6";
  7910.  
  7911.         p1.caption="Parameter 1";
  7912.         p1.default=(1.0,0.0);
  7913.    
  7914.  
  7915.         p2.caption="Parameter 2";
  7916.         p2.default=(1.0,0.0);
  7917.    
  7918.  
  7919.         bailout.caption="Bailout value";
  7920.         bailout.default=100.0;
  7921.    
  7922.  
  7923.         test.caption = "Bailout test";
  7924.         test.default = 0;
  7925.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7926.         test.hint = "Original formula uses mod by default.";
  7927.    
  7928.  
  7929.         fn1.caption="Function 1";
  7930.         fn1.default = "ident" ;
  7931.   
  7932.  
  7933.         fn2.caption="Function 2";
  7934.         fn2.default = "ident" ;
  7935.   
  7936.     }
  7937. }
  7938.  
  7939.  
  7940. gpm-jtchc2  {//Translation and modification of J_TchebycnewC2
  7941.              //from newtchb2.frm
  7942.              //by Gedeon Peteri, October 1999
  7943. complex c;
  7944. parameter complex p1;
  7945. parameter complex p2;
  7946. parameter int test;
  7947. parameter real bailout;
  7948.  
  7949.     void init(void)
  7950.     {
  7951.         z=fn2(pixel);
  7952.         c=p1;
  7953.     }
  7954.     void loop(void)
  7955.     {
  7956.         z=fn1(p2*(c*(z*z-2)));
  7957.     }
  7958.     bool bailout(void)
  7959.     {
  7960.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  7961.     }
  7962.     void description(void)
  7963.     {
  7964.         this.title="gpm-jtchc2";
  7965.  
  7966.         p1.caption="Parameter 1";
  7967.         p1.default=(0.7,0.0);
  7968.    
  7969.  
  7970.         p2.caption="Parameter 2";
  7971.         p2.default=(1.0,0.0);
  7972.    
  7973.  
  7974.         bailout.caption="Bailout value";
  7975.         bailout.default=100.0;
  7976.    
  7977.  
  7978.         test.caption = "Bailout test";
  7979.         test.default = 0;
  7980.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  7981.         test.hint = "Original formula uses mod by default.";
  7982.    
  7983.  
  7984.         fn1.caption="Function 1";
  7985.         fn1.default = "ident" ;
  7986.   
  7987.  
  7988.         fn2.caption="Function 2";
  7989.         fn2.default = "ident" ;
  7990.   
  7991.     }
  7992. }
  7993.  
  7994.  
  7995. gpm-jtchc3  {//Translation and modification of J_TchebycnewC3
  7996.              //from newtchb2.frm
  7997.              //by Gedeon Peteri, October 1999
  7998. complex c;
  7999. parameter complex p1;
  8000. parameter int test;
  8001. parameter real bailout;
  8002.  
  8003.     void init(void)
  8004.     {
  8005.         z=fn2(pixel);
  8006.         c=p1;
  8007.     }
  8008.     void loop(void)
  8009.     {
  8010.         z = c*z*(z*z-3);
  8011.  
  8012.     }
  8013.     bool bailout(void)
  8014.     {
  8015.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8016.     }
  8017.     void description(void)
  8018.     {
  8019.         this.title="gpm-jtchc3";
  8020.  
  8021.         p1.caption="Parameter 1";
  8022.         p1.default=(0.7,0.0);
  8023.    
  8024.  
  8025.         p2.caption="Parameter 2";
  8026.         p2.default=(1.0,0.0);
  8027.    
  8028.  
  8029.         bailout.caption="Bailout value";
  8030.         bailout.default=100.0;
  8031.    
  8032.  
  8033.         test.caption = "Bailout test";
  8034.         test.default = 0;
  8035.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8036.         test.hint = "Original formula uses mod by default.";
  8037.    
  8038.  
  8039.         fn1.caption="Function 1";
  8040.         fn1.default = "ident" ;
  8041.   
  8042.  
  8043.         fn2.caption="Function 2";
  8044.         fn2.default = "ident" ;
  8045.   
  8046.     }
  8047. }
  8048.  
  8049.  
  8050. gpm-jtchc4  {//Translation and modification of J_TchebycnewC4
  8051.              //from newtchb2.frm
  8052.              //by Gedeon Peteri, October 1999
  8053. complex c;
  8054. parameter complex p1;
  8055. parameter complex p2;
  8056. parameter int test;
  8057. parameter real bailout;
  8058.  
  8059.     void init(void)
  8060.     {
  8061.         z=fn2(pixel);
  8062.         c=p1;
  8063.     }
  8064.     void loop(void)
  8065.     {
  8066.         z=fn1(p2*(c*(z*z*(z*z-4)+2)));
  8067.     }
  8068.     bool bailout(void)
  8069.     {
  8070.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8071.     }
  8072.     void description(void)
  8073.     {
  8074.         this.title="gpm-jtchc4";
  8075.  
  8076.         p1.caption="Parameter 1";
  8077.         p1.default=(0.5,0.0);
  8078.    
  8079.  
  8080.         p2.caption="Parameter 2";
  8081.         p2.default=(1.0,0.0);
  8082.    
  8083.  
  8084.         bailout.caption="Bailout value";
  8085.         bailout.default=100.0;
  8086.    
  8087.  
  8088.         test.caption = "Bailout test";
  8089.         test.default = 0;
  8090.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8091.         test.hint = "Original formula uses mod by default.";
  8092.    
  8093.  
  8094.         fn1.caption="Function 1";
  8095.         fn1.default = "ident" ;
  8096.   
  8097.  
  8098.         fn2.caption="Function 2";
  8099.         fn2.default = "ident" ;
  8100.   
  8101.     }
  8102. }
  8103.  
  8104.  
  8105. gpm-jtchc5  {//Translation and modification of J_TchebycnewC5
  8106.              //from newtchb2.frm
  8107.              //by Gedeon Peteri, October 1999
  8108. complex c;
  8109. parameter complex p1;
  8110. parameter complex p2;
  8111. parameter int test;
  8112. parameter real bailout;
  8113.  
  8114.     void init(void)
  8115.     {
  8116.         z=fn2(pixel);
  8117.         c=p1;
  8118.     }
  8119.     void loop(void)
  8120.     {
  8121.         z=fn1(p2*(c*(z*z*(z*z*(z*z-6)+9)-2)));
  8122.     }
  8123.     bool bailout(void)
  8124.     {
  8125.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8126.     }
  8127.     void description(void)
  8128.     {
  8129.         this.title="gpm-jtchc5";
  8130.  
  8131.         p1.caption="Parameter 1";
  8132.         p1.default=(1.0,0.0);
  8133.    
  8134.  
  8135.         p2.caption="Parameter 2";
  8136.         p2.default=(1.0,0.0);
  8137.    
  8138.  
  8139.         bailout.caption="Bailout value";
  8140.         bailout.default=100.0;
  8141.    
  8142.  
  8143.         test.caption = "Bailout test";
  8144.         test.default = 0;
  8145.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8146.         test.hint = "Original formula uses mod by default.";
  8147.    
  8148.  
  8149.         fn1.caption="Function 1";
  8150.         fn1.default = "ident" ;
  8151.   
  8152.  
  8153.         fn2.caption="Function 2";
  8154.         fn2.default = "ident" ;
  8155.   
  8156.     }
  8157. }
  8158.  
  8159.  
  8160. gpm-jtchc6  {//Translation and modification of J_TchebycnewC6
  8161.              //from newtchb2.frm
  8162.              //by Gedeon Peteri, October 1999
  8163. complex c;
  8164. parameter complex p1;
  8165. parameter complex p2;
  8166. parameter int test;
  8167. parameter real bailout;
  8168.  
  8169.     void init(void)
  8170.     {
  8171.         z=fn2(pixel);
  8172.         c=p1;
  8173.     }
  8174.     void loop(void)
  8175.     {
  8176.         z=fn1(p2*(c*(z*z*(z*z*(z*z-6)+9)-2)));
  8177.     }
  8178.     bool bailout(void)
  8179.     {
  8180.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8181.     }
  8182.     void description(void)
  8183.     {
  8184.         this.title="gpm-jtchc6";
  8185.  
  8186.         p1.caption="Parameter 1";
  8187.         p1.default=(0.6,0.0);
  8188.    
  8189.  
  8190.         p2.caption="Parameter 2";
  8191.         p2.default=(1.0,0.0);
  8192.    
  8193.  
  8194.         bailout.caption="Bailout value";
  8195.         bailout.default=100.0;
  8196.    
  8197.  
  8198.         test.caption = "Bailout test";
  8199.         test.default = 0;
  8200.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8201.         test.hint = "Original formula uses mod by default.";
  8202.    
  8203.  
  8204.         fn1.caption="Function 1";
  8205.         fn1.default = "ident" ;
  8206.   
  8207.  
  8208.         fn2.caption="Function 2";
  8209.         fn2.default = "ident" ;
  8210.   
  8211.     }
  8212. }
  8213.  
  8214.  
  8215. gpm-jtchc7  {//Translation and modification of J_TchebycnewC7
  8216.              //from newtchb2.frm
  8217.              //by Gedeon Peteri, October 1999
  8218. complex c;
  8219. parameter complex p1;
  8220. parameter complex p2;
  8221. parameter int test;
  8222. parameter real bailout;
  8223.  
  8224.     void init(void)
  8225.     {
  8226.         z=fn2(pixel);
  8227.         c=p1;
  8228.     }
  8229.     void loop(void)
  8230.     {
  8231.         z=fn1(p2*(c*z*(z*z*(z*z*(z*z-7)+14)-7)));
  8232.     }
  8233.     bool bailout(void)
  8234.     {
  8235.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8236.     }
  8237.     void description(void)
  8238.     {
  8239.         this.title="gpm-jtchc7";
  8240.  
  8241.         p1.caption="Parameter 1";
  8242.         p1.default=(0.5,0.0);
  8243.    
  8244.  
  8245.         p2.caption="Parameter 2";
  8246.         p2.default=(1.0,0.0);
  8247.    
  8248.  
  8249.         bailout.caption="Bailout value";
  8250.         bailout.default=100.0;
  8251.    
  8252.  
  8253.         test.caption = "Bailout test";
  8254.         test.default = 0;
  8255.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8256.         test.hint = "Original formula uses mod by default.";
  8257.    
  8258.  
  8259.         fn1.caption="Function 1";
  8260.         fn1.default = "ident" ;
  8261.   
  8262.  
  8263.         fn2.caption="Function 2";
  8264.         fn2.default = "ident" ;
  8265.   
  8266.     }
  8267. }
  8268.  
  8269.  
  8270. gpm-jtchs2  {//Translation and modification of J_TchebycnewS2
  8271.              //from newtchb2.frm
  8272.              //by Gedeon Peteri, October 1999
  8273. complex c;
  8274. parameter complex p1;
  8275. parameter complex p2;
  8276. parameter int test;
  8277. parameter real bailout;
  8278.  
  8279.     void init(void)
  8280.     {
  8281.         z=fn2(pixel);
  8282.         c=p1;
  8283.     }
  8284.     void loop(void)
  8285.     {
  8286.         z=fn1(p2*(c*(z*z-1)));
  8287.     }
  8288.     bool bailout(void)
  8289.     {
  8290.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8291.     }
  8292.     void description(void)
  8293.     {
  8294.         this.title="gpm-jtchs2";
  8295.  
  8296.         p1.caption="Parameter 1";
  8297.         p1.default=(1.0,0.0);
  8298.    
  8299.  
  8300.         p2.caption="Parameter 2";
  8301.         p2.default=(1.0,0.0);
  8302.    
  8303.  
  8304.         bailout.caption="Bailout value";
  8305.         bailout.default=100.0;
  8306.    
  8307.  
  8308.         test.caption = "Bailout test";
  8309.         test.default = 0;
  8310.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8311.         test.hint = "Original formula uses mod by default.";
  8312.    
  8313.  
  8314.         fn1.caption="Function 1";
  8315.         fn1.default = "ident" ;
  8316.   
  8317.  
  8318.         fn2.caption="Function 2";
  8319.         fn2.default = "ident" ;
  8320.   
  8321.     }
  8322. }
  8323.  
  8324.  
  8325. gpm-jtchs3  {//Translation and modification of J_TchebycnewS3
  8326.              //from newtchb2.frm
  8327.              //by Gedeon Peteri, October 1999
  8328. complex c;
  8329. parameter complex p1;
  8330. parameter complex p2;
  8331. parameter int test;
  8332. parameter real bailout;
  8333.  
  8334.     void init(void)
  8335.     {
  8336.         z=fn2(pixel);
  8337.         c=p1;
  8338.     }
  8339.     void loop(void)
  8340.     {
  8341.         z=fn1(p2*(c*z*(z*z-2)));
  8342.     }
  8343.     bool bailout(void)
  8344.     {
  8345.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8346.     }
  8347.     void description(void)
  8348.     {
  8349.         this.title="gpm-jtchs3";
  8350.  
  8351.         p1.caption="Parameter 1";
  8352.         p1.default=(1.0,0.0);
  8353.    
  8354.  
  8355.         p2.caption="Parameter 2";
  8356.         p2.default=(1.0,0.0);
  8357.    
  8358.  
  8359.         bailout.caption="Bailout value";
  8360.         bailout.default=100.0;
  8361.    
  8362.  
  8363.         test.caption = "Bailout test";
  8364.         test.default = 0;
  8365.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8366.         test.hint = "Original formula uses mod by default.";
  8367.    
  8368.  
  8369.         fn1.caption="Function 1";
  8370.         fn1.default = "ident" ;
  8371.   
  8372.  
  8373.         fn2.caption="Function 2";
  8374.         fn2.default = "ident" ;
  8375.   
  8376.     }
  8377. }
  8378.  
  8379.  
  8380. gpm-jtchs4  {//Translation and modification of J_TchebycnewS4
  8381.              //from newtchb2.frm
  8382.              //by Gedeon Peteri, October 1999
  8383. complex c;
  8384. parameter complex p1;
  8385. parameter complex p2;
  8386. parameter int test;
  8387. parameter real bailout;
  8388.  
  8389.     void init(void)
  8390.     {
  8391.         z=fn2(pixel);
  8392.         c=p1;
  8393.     }
  8394.     void loop(void)
  8395.     {
  8396.         z=fn1(p2*(c*(z*z*(z*z-3)+1)));
  8397.     }
  8398.     bool bailout(void)
  8399.     {
  8400.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8401.     }
  8402.     void description(void)
  8403.     {
  8404.         this.title="gpm-jtchs4";
  8405.  
  8406.         p1.caption="Parameter 1";
  8407.         p1.default=(1.0,0.0);
  8408.    
  8409.  
  8410.         p2.caption="Parameter 2";
  8411.         p2.default=(1.0,0.0);
  8412.    
  8413.  
  8414.         bailout.caption="Bailout value";
  8415.         bailout.default=100.0;
  8416.    
  8417.  
  8418.         test.caption = "Bailout test";
  8419.         test.default = 0;
  8420.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8421.         test.hint = "Original formula uses mod by default.";
  8422.    
  8423.  
  8424.         fn1.caption="Function 1";
  8425.         fn1.default = "ident" ;
  8426.   
  8427.  
  8428.         fn2.caption="Function 2";
  8429.         fn2.default = "ident" ;
  8430.   
  8431.     }
  8432. }
  8433.  
  8434.  
  8435. gpm-jtchs5  {//Translation and modification of J_TchebycnewS5
  8436.              //from newtchb2.frm
  8437.              //by Gedeon Peteri, October 1999
  8438. complex c;
  8439. parameter complex p1;
  8440. parameter complex p2;
  8441. parameter int test;
  8442. parameter real bailout;
  8443.  
  8444.     void init(void)
  8445.     {
  8446.         z=fn2(pixel);
  8447.         c=p1;
  8448.     }
  8449.     void loop(void)
  8450.     {
  8451.         z=fn1(p2*(c*z*(z*z*(z*z-4)+3)));
  8452.     }
  8453.     bool bailout(void)
  8454.     {
  8455.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8456.     }
  8457.     void description(void)
  8458.     {
  8459.         this.title="gpm-jtchs5";
  8460.  
  8461.         p1.caption="Parameter 1";
  8462.         p1.default=(1.0,0.0);
  8463.    
  8464.  
  8465.         p2.caption="Parameter 2";
  8466.         p2.default=(1.0,0.0);
  8467.    
  8468.  
  8469.         bailout.caption="Bailout value";
  8470.         bailout.default=100.0;
  8471.    
  8472.  
  8473.         test.caption = "Bailout test";
  8474.         test.default = 0;
  8475.         test.hint = "Original formula uses mod by default.";
  8476.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8477.    
  8478.  
  8479.         fn1.caption="Function 1";
  8480.         fn1.default = "ident" ;
  8481.   
  8482.  
  8483.         fn2.caption="Function 2";
  8484.         fn2.default = "ident" ;
  8485.   
  8486.     }
  8487. }
  8488.  
  8489.  
  8490. gpm-jtchs6  {//Translation and modification of J_TchebycnewS6
  8491.              //from newtchb2.frm
  8492.              //by Gedeon Peteri, October 1999
  8493. complex c;
  8494. parameter complex p1;
  8495. parameter complex p2;
  8496. parameter int test;
  8497. parameter real bailout;
  8498.  
  8499.     void init(void)
  8500.     {
  8501.         z=fn2(pixel);
  8502.         c=p1;
  8503.     }
  8504.     void loop(void)
  8505.     {
  8506.         z=fn1(p2*(c*(z*z*(z*z*(z*z-5)+6)-1)));
  8507.     }
  8508.     bool bailout(void)
  8509.     {
  8510.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8511.     }
  8512.     void description(void)
  8513.     {
  8514.         this.title="gpm-jtchs6";
  8515.  
  8516.         p1.caption="Parameter 1";
  8517.         p1.default=(1.0,0.0);
  8518.    
  8519.  
  8520.         p2.caption="Parameter 2";
  8521.         p2.default=(1.0,0.0);
  8522.    
  8523.  
  8524.         bailout.caption="Bailout value";
  8525.         bailout.default=100.0;
  8526.    
  8527.  
  8528.         test.caption = "Bailout test";
  8529.         test.default = 0;
  8530.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8531.         test.hint = "Original formula uses mod by default.";
  8532.    
  8533.  
  8534.         fn1.caption="Function 1";
  8535.         fn1.default = "ident" ;
  8536.   
  8537.  
  8538.         fn2.caption="Function 2";
  8539.         fn2.default = "ident" ;
  8540.   
  8541.     }
  8542. }
  8543.  
  8544.  
  8545. gpm-jtchs7  {//Translation and modification of J_TchebycnewS7
  8546.              //from newtchb2.frm
  8547.              //by Gedeon Peteri, October 1999
  8548. complex c;
  8549. parameter complex p1;
  8550. parameter complex p2;
  8551. parameter int test;
  8552. parameter real bailout;
  8553.  
  8554.     void init(void)
  8555.     {
  8556.         z=fn2(pixel);
  8557.         c=p1;
  8558.     }
  8559.     void loop(void)
  8560.     {
  8561.         z=fn1(p2*(c*z*(z*z*(z*z*(z*z-6)+10)-4)));
  8562.     }
  8563.     bool bailout(void)
  8564.     {
  8565.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8566.     }
  8567.     void description(void)
  8568.     {
  8569.         this.title="gpm-jtchs7";
  8570.  
  8571.         p1.caption="Parameter 1";
  8572.         p1.default=(1.0,0.0);
  8573.    
  8574.  
  8575.         p2.caption="Parameter 2";
  8576.         p2.default=(1.0,0.0);
  8577.    
  8578.  
  8579.         bailout.caption="Bailout value";
  8580.         bailout.default=100.0;
  8581.    
  8582.  
  8583.         test.caption = "Bailout test";
  8584.         test.default = 0;
  8585.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8586.         test.hint = "Original formula uses mod by default.";
  8587.    
  8588.  
  8589.         fn1.caption="Function 1";
  8590.         fn1.default = "ident" ;
  8591.   
  8592.  
  8593.         fn2.caption="Function 2";
  8594.         fn2.default = "ident" ;
  8595.   
  8596.     }
  8597. }
  8598.  
  8599.  
  8600. gpm-jtcht2  {//Translation and modification of J_TchebycnewT2
  8601.              //from newtchb2.frm
  8602.              //by Gedeon Peteri, October 1999
  8603. complex c;
  8604. parameter complex p1;
  8605. parameter complex p2;
  8606. parameter int test;
  8607. parameter real bailout;
  8608.  
  8609.     void init(void)
  8610.     {
  8611.         z=fn2(pixel);
  8612.         c=p1;
  8613.     }
  8614.     void loop(void)
  8615.     {
  8616.         z=fn1(p2*(c*(2*z*z-1)));
  8617.     }
  8618.     bool bailout(void)
  8619.     {
  8620.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8621.     }
  8622.     void description(void)
  8623.     {
  8624.         this.title="gpm-jtcht2";
  8625.  
  8626.         p1.caption="Parameter 1";
  8627.         p1.default=(0.7,0.0);
  8628.    
  8629.  
  8630.         p2.caption="Parameter 2";
  8631.         p2.default=(1.0,0.0);
  8632.    
  8633.  
  8634.         bailout.caption="Bailout value";
  8635.         bailout.default=100.0;
  8636.    
  8637.  
  8638.         test.caption = "Bailout test";
  8639.         test.default = 0;
  8640.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8641.         test.hint = "Original formula uses mod by default.";
  8642.    
  8643.  
  8644.         fn1.caption="Function 1";
  8645.         fn1.default = "ident" ;
  8646.   
  8647.  
  8648.         fn2.caption="Function 2";
  8649.         fn2.default = "ident" ;
  8650.   
  8651.     }
  8652. }
  8653.  
  8654.  
  8655. gpm-jtcht3  {//Translation and modification of J_TchebycnewT3
  8656.              //from newtchb2.frm
  8657.              //by Gedeon Peteri, October 1999
  8658. complex c;
  8659. parameter complex p1;
  8660. parameter complex p2;
  8661. parameter int test;
  8662. parameter real bailout;
  8663.  
  8664.     void init(void)
  8665.     {
  8666.         z=fn2(pixel);
  8667.         c=p1;
  8668.     }
  8669.     void loop(void)
  8670.     {
  8671.         z=fn1(p2*(c*z*(4*z*z-3)));
  8672.     }
  8673.     bool bailout(void)
  8674.     {
  8675.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8676.     }
  8677.     void description(void)
  8678.     {
  8679.         this.title="gpm-jtcht3";
  8680.  
  8681.         p1.caption="Parameter 1";
  8682.         p1.default=(0.7,0.0);
  8683.    
  8684.  
  8685.         p2.caption="Parameter 2";
  8686.         p2.default=(1.0,0.0);
  8687.    
  8688.  
  8689.         bailout.caption="Bailout value";
  8690.         bailout.default=100.0;
  8691.    
  8692.  
  8693.         test.caption = "Bailout test";
  8694.         test.default = 0;
  8695.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8696.         test.hint = "Original formula uses mod by default.";
  8697.    
  8698.  
  8699.         fn1.caption="Function 1";
  8700.         fn1.default = "ident" ;
  8701.   
  8702.  
  8703.         fn2.caption="Function 2";
  8704.         fn2.default = "ident" ;
  8705.   
  8706.     }
  8707. }
  8708.  
  8709.  
  8710. gpm-jtcht4  {//Translation and modification of J_TchebycnewT4
  8711.              //from newtchb2.frm
  8712.              //by Gedeon Peteri, October 1999
  8713. complex c;
  8714. parameter complex p1;
  8715. parameter complex p2;
  8716. parameter int test;
  8717. parameter real bailout;
  8718.  
  8719.     void init(void)
  8720.     {
  8721.         z=fn2(pixel);
  8722.         c=p1;
  8723.     }
  8724.     void loop(void)
  8725.     {
  8726.         z=fn1(p2*(c*(z*z*(8*z*z+8)+1)));
  8727.     }
  8728.     bool bailout(void)
  8729.     {
  8730.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8731.     }
  8732.     void description(void)
  8733.     {
  8734.         this.title="gpm-jtcht4";
  8735.  
  8736.         p1.caption="Parameter 1";
  8737.         p1.default=(0.2,0.0);
  8738.    
  8739.  
  8740.         p2.caption="Parameter 2";
  8741.         p2.default=(1.0,0.0);
  8742.    
  8743.  
  8744.         bailout.caption="Bailout value";
  8745.         bailout.default=100.0;
  8746.    
  8747.  
  8748.         test.caption = "Bailout test";
  8749.         test.default = 0;
  8750.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8751.         test.hint = "Original formula uses mod by default.";
  8752.    
  8753.  
  8754.         fn1.caption="Function 1";
  8755.         fn1.default = "ident" ;
  8756.   
  8757.  
  8758.         fn2.caption="Function 2";
  8759.         fn2.default = "ident" ;
  8760.   
  8761.     }
  8762. }
  8763.  
  8764.  
  8765. gpm-jtcht5  {//Translation and modification of J_TchebycnewT5
  8766.              //from newtchb2.frm
  8767.              //by Gedeon Peteri, October 1999
  8768. complex c;
  8769. parameter complex p1;
  8770. parameter complex p2;
  8771. parameter int test;
  8772. parameter real bailout;
  8773.  
  8774.     void init(void)
  8775.     {
  8776.         z=fn2(pixel);
  8777.         c=p1;
  8778.     }
  8779.     void loop(void)
  8780.     {
  8781.         z=fn1(p2*(c*(z*(z*z*(16*z*z-20)+5))));
  8782.     }
  8783.     bool bailout(void)
  8784.     {
  8785.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8786.     }
  8787.     void description(void)
  8788.     {
  8789.         this.title="gpm-jtcht5";
  8790.  
  8791.         p1.caption="Parameter 1";
  8792.         p1.default=(0.5,0.0);
  8793.    
  8794.  
  8795.         p2.caption="Parameter 2";
  8796.         p2.default=(1.0,0.0);
  8797.    
  8798.  
  8799.         bailout.caption="Bailout value";
  8800.         bailout.default=100.0;
  8801.    
  8802.  
  8803.         test.caption = "Bailout test";
  8804.         test.default = 0;
  8805.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8806.         test.hint = "Original formula uses mod by default.";
  8807.    
  8808.  
  8809.         fn1.caption="Function 1";
  8810.         fn1.default = "ident" ;
  8811.   
  8812.  
  8813.         fn2.caption="Function 2";
  8814.         fn2.default = "ident" ;
  8815.   
  8816.     }
  8817. }
  8818.  
  8819.  
  8820. gpm-jtcht6  {//Translation and modification of J_TchebycnewT6
  8821.              //from newtchb2.frm
  8822.              //by Gedeon Peteri, October 1999
  8823. complex c;
  8824. parameter complex p1;
  8825. parameter complex p2;
  8826. parameter int test;
  8827. parameter real bailout;
  8828.  
  8829.     void init(void)
  8830.     {
  8831.         z=fn2(pixel);
  8832.         c=p1;
  8833.     }
  8834.     void loop(void)
  8835.     {
  8836.         z=fn1(p2*(c*(z*z*(z*z*(32*z*z-48)+18)-1)));
  8837.     }
  8838.     bool bailout(void)
  8839.     {
  8840.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8841.     }
  8842.     void description(void)
  8843.     {
  8844.         this.title="gpm-jtcht6";
  8845.  
  8846.         p1.caption="Parameter 1";
  8847.         p1.default=(0.3,0.0);
  8848.    
  8849.  
  8850.         p2.caption="Parameter 2";
  8851.         p2.default=(1.0,0.0);
  8852.    
  8853.  
  8854.         bailout.caption="Bailout value";
  8855.         bailout.default=100.0;
  8856.    
  8857.  
  8858.         test.caption = "Bailout test";
  8859.         test.default = 0;
  8860.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8861.         test.hint = "Original formula uses mod by default.";
  8862.    
  8863.  
  8864.         fn1.caption="Function 1";
  8865.         fn1.default = "ident" ;
  8866.   
  8867.  
  8868.         fn2.caption="Function 2";
  8869.         fn2.default = "ident" ;
  8870.   
  8871.     }
  8872. }
  8873.  
  8874.  
  8875. gpm-jtcht7  {//Translation and modification of J_TchebycnewT7
  8876.              //from newtchb2.frm
  8877.              //by Gedeon Peteri, October 1999
  8878. complex c;
  8879. parameter complex p1;
  8880. parameter complex p2;
  8881. parameter int test;
  8882. parameter real bailout;
  8883.  
  8884.     void init(void)
  8885.     {
  8886.         z=fn2(pixel);
  8887.         c=p1;
  8888.     }
  8889.     void loop(void)
  8890.     {
  8891.         z=fn1(p2*(c*z*(z*z*(z*z*(64*z*z-112)+56)-7)));
  8892.     }
  8893.     bool bailout(void)
  8894.     {
  8895.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8896.     }
  8897.     void description(void)
  8898.     {
  8899.         this.title="gpm-jtcht7";
  8900.  
  8901.         p1.caption="Parameter 1";
  8902.         p1.default=(0.2,0.0);
  8903.    
  8904.  
  8905.         p2.caption="Parameter 2";
  8906.         p2.default=(1.0,0.0);
  8907.    
  8908.  
  8909.         bailout.caption="Bailout value";
  8910.         bailout.default=100.0;
  8911.    
  8912.  
  8913.         test.caption = "Bailout test";
  8914.         test.default = 0;
  8915.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8916.         test.hint = "Original formula uses mod by default.";
  8917.    
  8918.  
  8919.         fn1.caption="Function 1";
  8920.         fn1.default = "ident" ;
  8921.   
  8922.  
  8923.         fn2.caption="Function 2";
  8924.         fn2.default = "ident" ;
  8925.   
  8926.     }
  8927. }
  8928.  
  8929.  
  8930. gpm-jtchu2  {//Translation and modification of J_TchebycnewtU2
  8931.              //from newtchb2.frm
  8932.              //by Gedeon Peteri, October 1999
  8933. complex c;
  8934. parameter complex p1;
  8935. parameter complex p2;
  8936. parameter int test;
  8937. parameter real bailout;
  8938.  
  8939.     void init(void)
  8940.     {
  8941.         z=fn2(pixel);
  8942.         c=p1;
  8943.     }
  8944.     void loop(void)
  8945.     {
  8946.         z=fn1(p2*(c*(4*z*z-1)));
  8947.     }
  8948.     bool bailout(void)
  8949.     {
  8950.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  8951.     }
  8952.     void description(void)
  8953.     {
  8954.         this.title="gpm-jtchu2";
  8955.  
  8956.         p1.caption="Parameter 1";
  8957.         p1.default=(0.5,0.0);
  8958.    
  8959.  
  8960.         p2.caption="Parameter 2";
  8961.         p2.default=(1.0,0.0);
  8962.    
  8963.  
  8964.         bailout.caption="Bailout value";
  8965.         bailout.default=100.0;
  8966.    
  8967.  
  8968.         test.caption = "Bailout test";
  8969.         test.default = 0;
  8970.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  8971.         test.hint = "Original formula uses mod by default.";
  8972.    
  8973.  
  8974.         fn1.caption="Function 1";
  8975.         fn1.default = "ident" ;
  8976.   
  8977.  
  8978.         fn2.caption="Function 2";
  8979.         fn2.default = "ident" ;
  8980.   
  8981.     }
  8982. }
  8983.  
  8984.  
  8985. gpm-jtchu3  {//Translation and modification of J_TchebycnewtU3
  8986.              //from newtchb2.frm
  8987.              //by Gedeon Peteri, October 1999
  8988. complex c;
  8989. parameter complex p1;
  8990. parameter complex p2;
  8991. parameter int test;
  8992. parameter real bailout;
  8993.  
  8994.     void init(void)
  8995.     {
  8996.         z=fn2(pixel);
  8997.         c=p1;
  8998.     }
  8999.     void loop(void)
  9000.     {
  9001.         z=fn1(p2*(c*z*(8*z*z-4)));
  9002.     }
  9003.     bool bailout(void)
  9004.     {
  9005.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9006.     }
  9007.     void description(void)
  9008.     {
  9009.         this.title="gpm-jtchu3";
  9010.  
  9011.         p1.caption="Parameter 1";
  9012.         p1.default=(0.5,0.0);
  9013.    
  9014.  
  9015.         p2.caption="Parameter 2";
  9016.         p2.default=(1.0,0.0);
  9017.    
  9018.  
  9019.         bailout.caption="Bailout value";
  9020.         bailout.default=100.0;
  9021.    
  9022.  
  9023.         test.caption = "Bailout test";
  9024.         test.default = 0;
  9025.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9026.         test.hint = "Original formula uses mod by default.";
  9027.    
  9028.  
  9029.         fn1.caption="Function 1";
  9030.         fn1.default = "ident" ;
  9031.   
  9032.  
  9033.         fn2.caption="Function 2";
  9034.         fn2.default = "ident" ;
  9035.   
  9036.     }
  9037. }
  9038.  
  9039.  
  9040. gpm-jtchu4  {//Translation and modification of J_TchebycnewtU4
  9041.              //from newtchb2.frm
  9042.              //by Gedeon Peteri, October 1999
  9043. complex c;
  9044. parameter complex p1;
  9045. parameter complex p2;
  9046. parameter int test;
  9047. parameter real bailout;
  9048.  
  9049.     void init(void)
  9050.     {
  9051.         z=fn2(pixel);
  9052.         c=p1;
  9053.     }
  9054.     void loop(void)
  9055.     {
  9056.         z=fn1(p2*(c*(z*z*(16*z*z-12)+1)));
  9057.     }
  9058.     bool bailout(void)
  9059.     {
  9060.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9061.     }
  9062.     void description(void)
  9063.     {
  9064.         this.title="gpm-jtchu4";
  9065.  
  9066.         p1.caption="Parameter 1";
  9067.         p1.default=(0.3,0.0);
  9068.    
  9069.  
  9070.         p2.caption="Parameter 2";
  9071.         p2.default=(1.0,0.0);
  9072.    
  9073.  
  9074.         bailout.caption="Bailout value";
  9075.         bailout.default=100.0;
  9076.    
  9077.  
  9078.         test.caption = "Bailout test";
  9079.         test.default = 0;
  9080.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9081.         test.hint = "Original formula uses mod by default.";
  9082.    
  9083.  
  9084.         fn1.caption="Function 1";
  9085.         fn1.default = "ident" ;
  9086.   
  9087.  
  9088.         fn2.caption="Function 2";
  9089.         fn2.default = "ident" ;
  9090.   
  9091.     }
  9092. }
  9093.  
  9094.  
  9095. gpm-jtchu5  {//Translation and modification of J_TchebycnewtU5
  9096.              //from newtchb2.frm
  9097.              //by Gedeon Peteri, October 1999
  9098. complex c;
  9099. parameter complex p1;
  9100. parameter complex p2;
  9101. parameter int test;
  9102. parameter real bailout;
  9103.  
  9104.     void init(void)
  9105.     {
  9106.         z=fn2(pixel);
  9107.         c=p1;
  9108.     }
  9109.     void loop(void)
  9110.     {
  9111.         z=fn1(p2*(c*z*(z*z*(32*z*z-32)+6)));
  9112.     }
  9113.     bool bailout(void)
  9114.     {
  9115.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9116.     }
  9117.     void description(void)
  9118.     {
  9119.         this.title="gpm-jtchu5";
  9120.  
  9121.         p1.caption="Parameter 1";
  9122.         p1.default=(0.3,0.0);
  9123.    
  9124.  
  9125.         p2.caption="Parameter 2";
  9126.         p2.default=(1.0,0.0);
  9127.    
  9128.  
  9129.         bailout.caption="Bailout value";
  9130.         bailout.default=100.0;
  9131.    
  9132.  
  9133.         test.caption = "Bailout test";
  9134.         test.default = 0;
  9135.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9136.         test.hint = "Original formula uses mod by default.";
  9137.    
  9138.  
  9139.         fn1.caption="Function 1";
  9140.         fn1.default = "ident" ;
  9141.   
  9142.  
  9143.         fn2.caption="Function 2";
  9144.         fn2.default = "ident" ;
  9145.   
  9146.     }
  9147. }
  9148.  
  9149.  
  9150. gpm-jtchu6  {//Translation and modification of J_TchebycnewtU6
  9151.              //from newtchb2.frm
  9152.              //by Gedeon Peteri, October 1999
  9153. complex c;
  9154. parameter complex p1;
  9155. parameter complex p2;
  9156. parameter int test;
  9157. parameter real bailout;
  9158.  
  9159.     void init(void)
  9160.     {
  9161.         z=fn2(pixel);
  9162.         c=p1;
  9163.     }
  9164.     void loop(void)
  9165.     {
  9166.         z=fn1(p2*(c*(z*z*(z*z*(64*z*z-80)+24)-1)));
  9167.     }
  9168.     bool bailout(void)
  9169.     {
  9170.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9171.     }
  9172.     void description(void)
  9173.     {
  9174.         this.title="gpm-jtchu6";
  9175.  
  9176.         p1.caption="Parameter 1";
  9177.         p1.default=(0.3,0.0);
  9178.    
  9179.  
  9180.         p2.caption="Parameter 2";
  9181.         p2.default=(1.0,0.0);
  9182.    
  9183.  
  9184.         bailout.caption="Bailout value";
  9185.         bailout.default=100.0;
  9186.    
  9187.  
  9188.         test.caption = "Bailout test";
  9189.         test.default = 0;
  9190.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9191.         test.hint = "Original formula uses mod by default.";
  9192.    
  9193.  
  9194.         fn1.caption="Function 1";
  9195.         fn1.default = "ident" ;
  9196.   
  9197.  
  9198.         fn2.caption="Function 2";
  9199.         fn2.default = "ident" ;
  9200.   
  9201.     }
  9202. }
  9203.  
  9204.  
  9205. gpm-jtchu7  {//Translation and modification of J_TchebycnewtU7
  9206.              //from newtchb2.frm
  9207.              //by Gedeon Peteri, October 1999
  9208. complex c;
  9209. parameter complex p1;
  9210. parameter complex p2;
  9211. parameter int test;
  9212. parameter real bailout;
  9213.  
  9214.     void init(void)
  9215.     {
  9216.         z=fn2(pixel);
  9217.         c=p1;
  9218.     }
  9219.     void loop(void)
  9220.     {
  9221.         z=fn1(p2*(c*z*(z*z*(z*z*(128*z*z-192)+80)-8)));
  9222.     }
  9223.     bool bailout(void)
  9224.     {
  9225.         return((test == 0 && |z| <= bailout) ||                                        (test == 1 && sqr(real(z)) <= bailout) ||                               (test == 2 && sqr(imag(z)) <= bailout) ||                               (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) ||  (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) ||  (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||         (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9226.     }
  9227.     void description(void)
  9228.     {
  9229.         this.title="gpm-jtchu7";
  9230.  
  9231.         p1.caption="Parameter 1";
  9232.         p1.default=(0.3,0.0);
  9233.    
  9234.  
  9235.         p2.caption="Parameter 2";
  9236.         p2.default=(1.0,0.0);
  9237.    
  9238.  
  9239.         bailout.caption="Bailout value";
  9240.         bailout.default=100.0;
  9241.    
  9242.  
  9243.         test.caption = "Bailout test";
  9244.         test.default = 0;
  9245.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9246.         test.hint = "Original formula uses mod by default.";
  9247.    
  9248.  
  9249.         fn1.caption="Function 1";
  9250.         fn1.default = "ident" ;
  9251.   
  9252.  
  9253.         fn2.caption="Function 2";
  9254.         fn2.default = "ident" ;
  9255.   
  9256.     }
  9257. }
  9258.  
  9259.  
  9260. comment
  9261. {
  9262. ;The following formulas with gpm-grav prefix are translations and slight
  9263. ;modifications of the original Gravijul formula written for Fractint by
  9264. ;Mark Christenson, and variations thereof by other authors
  9265. ;as noted in the comments for each formula.
  9266.  
  9267.  
  9268. }
  9269.  
  9270. gpm-grav01    {//Original Fractint formula "gravijul" by Mark Christenson
  9271.                //Translated to UF format and slightly modified by
  9272.                //Gedeon Peteri, December, 1999
  9273. complex w;
  9274. parameter complex p1;
  9275. parameter complex p2;
  9276. parameter int test;
  9277. parameter real bailout;
  9278.  
  9279.     void init(void)
  9280.     {
  9281.         z=fn4(pixel);
  9282.     }
  9283.     void loop(void)
  9284.     {
  9285.         w = fn1(z);
  9286.         z = fn3(p1/fn2(w*w)) + p2;
  9287.     }
  9288.     bool bailout(void)
  9289.     {
  9290.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9291.     }
  9292.     void description(void)
  9293.     {
  9294.         this.title="gpm-grav01";
  9295.  
  9296.         p1.caption="Parameter 1";
  9297.         p1.default=(0.6,0.6);
  9298.    
  9299.  
  9300.         p2.caption="Parameter 2";
  9301.         p2.default=(0.0,0.0);
  9302.    
  9303.  
  9304.         bailout.caption="Bailout value";
  9305.         bailout.default=4.0;
  9306.    
  9307.  
  9308.         test.caption = "Bailout test";
  9309.         test.default = 0;
  9310.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9311.         test.hint = "Original formula uses mod by default.";
  9312.    
  9313.  
  9314.         fn1.caption="Function 1";
  9315.         fn1.default = "ident" ;
  9316.   
  9317.  
  9318.         fn2.caption="Function 2";
  9319.         fn2.default = "sin" ;
  9320.   
  9321.  
  9322.         fn3.caption="Function 3";
  9323.         fn3.default = "sin" ;
  9324.   
  9325.  
  9326.         fn4.caption="Function 4";
  9327.         fn4.default = "ident" ;
  9328.   
  9329.     }
  9330. }
  9331.  
  9332.  
  9333. gpm-grav02    {//Original Fractint formula "gravijul-a1" by Mark Christenson
  9334.                //Translated to UF format and slightly modified by
  9335.                //Gedeon Peteri, December, 1999
  9336. complex q1;
  9337. parameter complex p3;
  9338. complex q2;
  9339. complex v;
  9340. complex w;
  9341. parameter complex p1;
  9342. parameter complex p2;
  9343. parameter int test;
  9344. parameter real bailout;
  9345.  
  9346.     void init(void)
  9347.     {
  9348.         q1=imag(p3);
  9349.         q2=real(p3);
  9350.         z=fn4(pixel);
  9351.     }
  9352.     void loop(void)
  9353.     {
  9354.         v = fn1(z);
  9355.         w = q1*(v*v);
  9356.         z = q2*fn3(p1/fn2(w)) + p2;
  9357.     }
  9358.     bool bailout(void)
  9359.     {
  9360.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9361.     }
  9362.     void description(void)
  9363.     {
  9364.         this.title="gpm-grav02";
  9365.  
  9366.         p1.caption="Parameter 1";
  9367.         p1.default=(0.6,0.6);
  9368.    
  9369.  
  9370.         p2.caption="Parameter 2";
  9371.         p2.default=(0.0,0.0);
  9372.    
  9373.  
  9374.         p3.caption="Parameter 3";
  9375.         p3.default=(1.0,1.0);
  9376.    
  9377.  
  9378.         bailout.caption="Bailout value";
  9379.         bailout.default=4.0;
  9380.    
  9381.  
  9382.         test.caption = "Bailout test";
  9383.         test.default = 0;
  9384.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9385.         test.hint = "Original formula uses mod by default.";
  9386.    
  9387.  
  9388.         fn1.caption="Function 1";
  9389.         fn1.default = "ident" ;
  9390.   
  9391.  
  9392.         fn2.caption="Function 2";
  9393.         fn2.default = "sin" ;
  9394.   
  9395.  
  9396.         fn3.caption="Function 3";
  9397.         fn3.default = "sin" ;
  9398.   
  9399.  
  9400.         fn4.caption="Function 4";
  9401.         fn4.default = "ident" ;
  9402.   
  9403.     }
  9404. }
  9405.  
  9406.  
  9407. gpm-grav03    {//Original Fractint formula "gravijul" by Mark Christenson
  9408.                //Variation "gravijul_2u" by Phil DiGiorgi
  9409.                //Translated to UF format and slightly modified by
  9410.                //Gedeon Peteri, December, 1999
  9411. complex Var_x;
  9412. complex Var_y;
  9413. complex w;
  9414. parameter complex p3;
  9415. complex v;
  9416. complex u;
  9417. parameter complex p1;
  9418. parameter complex p2;
  9419. parameter int test;
  9420. parameter real bailout;
  9421.  
  9422.     void init(void)
  9423.     {
  9424.         z=abs(pixel);
  9425.     }
  9426.     void loop(void)
  9427.     {
  9428.         Var_x = real(z);
  9429.         Var_y = imag(z);
  9430.         w = fn1(Var_x) + p3*Var_y;
  9431.         v = fn1(Var_y) + p3*Var_x;
  9432.         u = fn2(w + flip(v));
  9433.         z = fn4(p1/fn3(u*u)) + p2;
  9434.     }
  9435.     bool bailout(void)
  9436.     {
  9437.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9438.     }
  9439.     void description(void)
  9440.     {
  9441.         this.title="gpm-grav03";
  9442.  
  9443.         p1.caption="Parameter 1";
  9444.         p1.default=(0.5,0.5);
  9445.    
  9446.  
  9447.         p2.caption="Parameter 2";
  9448.         p2.default=(0.0,0.0);
  9449.    
  9450.  
  9451.         p3.caption="Parameter 3";
  9452.         p3.default=(0.1,0.0);
  9453.    
  9454.  
  9455.         bailout.caption="Bailout value";
  9456.         bailout.default=4.0;
  9457.    
  9458.  
  9459.         test.caption = "Bailout test";
  9460.         test.default = 0;
  9461.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9462.         test.hint = "Original formula uses mod by default.";
  9463.    
  9464.  
  9465.         fn1.caption="Function 1";
  9466.         fn1.default = "ident" ;
  9467.   
  9468.  
  9469.         fn2.caption="Function 2";
  9470.         fn2.default = "sin" ;
  9471.   
  9472.  
  9473.         fn3.caption="Function 3";
  9474.         fn3.default = "sin" ;
  9475.   
  9476.  
  9477.         fn4.caption="Function 4";
  9478.         fn4.default = "sin" ;
  9479.   
  9480.     }
  9481. }
  9482.  
  9483.  
  9484. gpm-grav04    {//Original Fractint formula "gravijul" by Mark Christenson
  9485.                //Variation "gravijul4" by Phil DiGiorgi
  9486.                //Translated to UF format and slightly modified by
  9487.                //Gedeon Peteri, December, 1999
  9488. complex v;
  9489. parameter complex p3;
  9490. complex w;
  9491. parameter complex p1;
  9492. parameter complex p2;
  9493. parameter int test;
  9494. parameter real bailout;
  9495.  
  9496.     void init(void)
  9497.     {
  9498.         z=abs(pixel);
  9499.     }
  9500.     void loop(void)
  9501.     {
  9502.         v = fn1(z)*p3;
  9503.         w = fn2(v*v);
  9504.         z = fn4(p1/fn3(w*w)) + p2;
  9505.     }
  9506.     bool bailout(void)
  9507.     {
  9508.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9509.     }
  9510.     void description(void)
  9511.     {
  9512.         this.title="gpm-grav04";
  9513.  
  9514.         p1.caption="Parameter 1";
  9515.         p1.default=(1.0,-1.0);
  9516.    
  9517.  
  9518.         p2.caption="Parameter 2";
  9519.         p2.default=(0.0,0.0);
  9520.    
  9521.  
  9522.         p3.caption="Parameter 3";
  9523.         p3.default=(0.7,0.7);
  9524.    
  9525.  
  9526.         bailout.caption="Bailout value";
  9527.         bailout.default=4.0;
  9528.    
  9529.  
  9530.         test.caption = "Bailout test";
  9531.         test.default = 0;
  9532.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9533.         test.hint = "Original formula uses mod by default.";
  9534.    
  9535.  
  9536.         fn1.caption="Function 1";
  9537.         fn1.default = "ident" ;
  9538.   
  9539.  
  9540.         fn2.caption="Function 2";
  9541.         fn2.default = "cos" ;
  9542.   
  9543.  
  9544.         fn3.caption="Function 3";
  9545.         fn3.default = "ident" ;
  9546.   
  9547.  
  9548.         fn4.caption="Function 4";
  9549.         fn4.default = "asin" ;
  9550.   
  9551.     }
  9552. }
  9553.  
  9554.  
  9555. gpm-grav05    {//Original Fractint formula "gravijul" by Mark Christenson
  9556.                //Variation "grav-11a" by Linda Allison
  9557.                //Translated to UF format and slightly modified by
  9558.                //Gedeon Peteri, December, 1999
  9559. complex c;
  9560. complex w;
  9561. parameter complex p1;
  9562. parameter int test;
  9563. parameter real bailout;
  9564.  
  9565.     void init(void)
  9566.     {
  9567.         z=fn4(pixel);
  9568.         c=fn4(pixel);
  9569.     }
  9570.     void loop(void)
  9571.     {
  9572.         w = fn1(z)*fn1(z);
  9573.         z = fn3(p1/fn2(w*w)) + c;
  9574.     }
  9575.     bool bailout(void)
  9576.     {
  9577.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9578.     }
  9579.     void description(void)
  9580.     {
  9581.         this.title="gpm-grav05";
  9582.  
  9583.         p1.caption="Parameter";
  9584.         p1.default=(1.0,0.0);
  9585.    
  9586.  
  9587.         bailout.caption="Bailout value";
  9588.         bailout.default=4.0;
  9589.    
  9590.  
  9591.         test.caption = "Bailout test";
  9592.         test.default = 0;
  9593.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9594.         test.hint = "Original formula uses mod by default.";
  9595.    
  9596.  
  9597.         fn1.caption="Function 1";
  9598.         fn1.default = "ident" ;
  9599.   
  9600.  
  9601.         fn2.caption="Function 2";
  9602.         fn2.default = "ident" ;
  9603.   
  9604.  
  9605.         fn3.caption="Function 3";
  9606.         fn3.default = "ident" ;
  9607.   
  9608.  
  9609.         fn4.caption="Function 4";
  9610.         fn4.default = "ident" ;
  9611.   
  9612.     }
  9613. }
  9614.  
  9615.  
  9616. gpm-grav06    {//Original Fractint formula "gravijul" by Mark Christenson
  9617.                //Variation "gravijul-v1" by Sylvie Gallet
  9618.                //Translated to UF format and slightly modified by
  9619.                //Gedeon Peteri, December, 1999
  9620. parameter complex p3;
  9621. complex w;
  9622. parameter complex p1;
  9623. parameter complex p2;
  9624. parameter int test;
  9625. parameter real bailout;
  9626.  
  9627.     void init(void)
  9628.     {
  9629.         z=fn4(pixel^p3);
  9630.     }
  9631.     void loop(void)
  9632.     {
  9633.         w = fn1(z);
  9634.         z = fn3(p1/fn2(w*w)) + p2;
  9635.     }
  9636.     bool bailout(void)
  9637.     {
  9638.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9639.     }
  9640.     void description(void)
  9641.     {
  9642.         this.title="gpm-grav06";
  9643.  
  9644.         p1.caption="Parameter 1";
  9645.         p1.default=(1.0,0.0);
  9646.    
  9647.  
  9648.         p2.caption="Parameter 2";
  9649.         p2.default=(0.0,0.0);
  9650.    
  9651.  
  9652.         p3.caption="Exponent";
  9653.         p3.default=(2.0,0.0);
  9654.    
  9655.  
  9656.         bailout.caption="Bailout value";
  9657.         bailout.default=4.0;
  9658.    
  9659.  
  9660.         test.caption = "Bailout test";
  9661.         test.default = 0;
  9662.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9663.         test.hint = "Original formula uses mod by default.";
  9664.    
  9665.  
  9666.         fn1.caption="Function 1";
  9667.         fn1.default = "ident" ;
  9668.   
  9669.  
  9670.         fn2.caption="Function 2";
  9671.         fn2.default = "cos" ;
  9672.   
  9673.  
  9674.         fn3.caption="Function 3";
  9675.         fn3.default = "ident" ;
  9676.   
  9677.  
  9678.         fn4.caption="Function 4";
  9679.         fn4.default = "ident" ;
  9680.   
  9681.     }
  9682. }
  9683.  
  9684.  
  9685. gpm-grav07    {//Original Fractint formula "gravijul" by Mark Christenson
  9686.                //Variation "gravijul-v2" by Sylvie Gallet
  9687.                //Translated to UF format and slightly modified by
  9688.                //Gedeon Peteri, December, 1999
  9689. complex w;
  9690. complex Var_x;
  9691. parameter complex p1;
  9692. complex Var_y;
  9693. parameter complex p2;
  9694. parameter int test;
  9695. parameter real bailout;
  9696.  
  9697.     void init(void)
  9698.     {
  9699.         z=fn4(pixel);
  9700.     }
  9701.     void loop(void)
  9702.     {
  9703.         w = fn1(real(z));
  9704.         Var_x = fn3(p1/fn2(w*w));
  9705.         w = fn1(imag(z));
  9706.         Var_y = fn3(p1/fn2(w*w));
  9707.         z = Var_x + flip(Var_y) + p2;
  9708.     }
  9709.     bool bailout(void)
  9710.     {
  9711.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9712.     }
  9713.     void description(void)
  9714.     {
  9715.         this.title="gpm-grav07";
  9716.  
  9717.         p1.caption="Parameter 1";
  9718.         p1.default=(1.0,1.0);
  9719.    
  9720.  
  9721.         p2.caption="Parameter 2";
  9722.         p2.default=(0.0,0.0);
  9723.    
  9724.  
  9725.         bailout.caption="Bailout value";
  9726.         bailout.default=512.0;
  9727.    
  9728.  
  9729.         test.caption = "Bailout test";
  9730.         test.default = 0;
  9731.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9732.         test.hint = "Original formula uses mod by default.";
  9733.    
  9734.  
  9735.         fn1.caption="Function 1";
  9736.         fn1.default = "log" ;
  9737.   
  9738.  
  9739.         fn2.caption="Function 2";
  9740.         fn2.default = "log" ;
  9741.   
  9742.  
  9743.         fn3.caption="Function 3";
  9744.         fn3.default = "ident" ;
  9745.   
  9746.  
  9747.         fn4.caption="Function 4";
  9748.         fn4.default = "ident" ;
  9749.   
  9750.     }
  9751. }
  9752.  
  9753.  
  9754. gpm-grav08    {//Original Fractint formula "gravijul" by Mark Christenson
  9755.                //Variation "gravijul-v3" by Sylvie Gallet
  9756.                //Translated to UF format and slightly modified by
  9757.                //Gedeon Peteri, December, 1999
  9758. complex w;
  9759. parameter complex p1;
  9760. parameter complex p2;
  9761. parameter int test;
  9762. parameter real bailout;
  9763.  
  9764.     void init(void)
  9765.     {
  9766.         z=fn4(pixel);
  9767.     }
  9768.     void loop(void)
  9769.     {
  9770.         w = fn1(z);
  9771.         z = fn3(fn2(w*w)^p1) + p2;
  9772.     }
  9773.     bool bailout(void)
  9774.     {
  9775.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9776.     }
  9777.     void description(void)
  9778.     {
  9779.         this.title="gpm-grav08";
  9780.  
  9781.         p1.caption="Exponent";
  9782.         p1.default=(1.5,0.0);
  9783.    
  9784.  
  9785.         p2.caption="Parameter";
  9786.         p2.default=(0.0,0.0);
  9787.    
  9788.  
  9789.         bailout.caption="Bailout value";
  9790.         bailout.default=4.0;
  9791.    
  9792.  
  9793.         test.caption = "Bailout test";
  9794.         test.default = 0;
  9795.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9796.         test.hint = "Original formula uses mod by default.";
  9797.    
  9798.  
  9799.         fn1.caption="Function 1";
  9800.         fn1.default = "sqrt" ;
  9801.   
  9802.  
  9803.         fn2.caption="Function 2";
  9804.         fn2.default = "sin" ;
  9805.   
  9806.  
  9807.         fn3.caption="Function 3";
  9808.         fn3.default = "ident" ;
  9809.   
  9810.  
  9811.         fn4.caption="Function 4";
  9812.         fn4.default = "ident" ;
  9813.   
  9814.     }
  9815. }
  9816.  
  9817.  
  9818. gpm-grav09    {//Original Fractint formula "gravijul" by Mark Christenson
  9819.                //Variation "gravellipse" by Kathy Roth
  9820.                //Translated to UF format and slightly modified by
  9821.                //Gedeon Peteri, December, 1999
  9822. complex a;
  9823. parameter complex p3;
  9824. complex b;
  9825. complex w;
  9826. parameter complex p1;
  9827. parameter complex p2;
  9828. parameter real bailout;
  9829.  
  9830.     void init(void)
  9831.     {
  9832.         z=fn4(pixel);
  9833.         a=real(p3);
  9834.         b=imag(p3);
  9835.     }
  9836.     void loop(void)
  9837.     {
  9838.         w = fn1(z);
  9839.         z = fn3(p1/fn2(w*w)) + p2;
  9840.     }
  9841.     bool bailout(void)
  9842.     {
  9843.         return(real(z) * real(z)/ a + imag(z) * imag(z)/b < bailout);
  9844.     }
  9845.     void description(void)
  9846.     {
  9847.         this.title="gpm-grav09";
  9848.  
  9849.         p1.caption="Parameter 1";
  9850.         p1.default=(1.0,1.0);
  9851.    
  9852.  
  9853.         p2.caption="Parameter 2";
  9854.         p2.default=(0.0,0.0);
  9855.    
  9856.  
  9857.         p3.caption="Parameter 3";
  9858.         p3.default=(0.5,0.5);
  9859.    
  9860.  
  9861.         bailout.caption="Bailout value";
  9862.         bailout.default=32.0;
  9863.    
  9864.  
  9865.         fn1.caption="Function 1";
  9866.         fn1.default = "ident" ;
  9867.   
  9868.  
  9869.         fn2.caption="Function 2";
  9870.         fn2.default = "sinh" ;
  9871.   
  9872.  
  9873.         fn3.caption="Function 3";
  9874.         fn3.default = "ident" ;
  9875.   
  9876.  
  9877.         fn4.caption="Function 4";
  9878.         fn4.default = "ident" ;
  9879.   
  9880.     }
  9881. }
  9882.  
  9883.  
  9884. comment
  9885. {
  9886. ;The following formulas with prefix gpm-sgxxx are
  9887. ;translations and modifications of some formulas
  9888. ;from Sylvie Gallet's gallet-3.frm,
  9889. ;gallet-4.frm, and gallet-6.frm.
  9890. ;Modifications are limited to addition of function in init
  9891. ;section, addition of a bailout test parameter, changing the hard
  9892. ;coded function (flip) and bailout to user definable ones.
  9893.  
  9894.  
  9895.  
  9896. }
  9897.  
  9898. gpm-sg302     {//Sylvie Gallet's Gallet-3-02
  9899.                //translated to UF format and slightly modified by
  9900.                //Gedeon Peteri, December, 1999
  9901. complex Var_x;
  9902. complex Var_y;
  9903. complex x1;
  9904. parameter complex p1;
  9905. parameter complex p2;
  9906. complex y1;
  9907. parameter int test;
  9908. parameter real bailout;
  9909.  
  9910.     void init(void)
  9911.     {
  9912.         z=fn4(pixel);
  9913.     }
  9914.     void loop(void)
  9915.     {
  9916.         Var_x = real(z);
  9917.         Var_y = imag(z);
  9918.         x1 = Var_x - p1*fn1(Var_y+p2*fn2(Var_y));
  9919.         y1 = Var_y - p1*fn1(Var_x+p2*fn2(Var_x));
  9920.         z = x1+fn3(y1);
  9921.     }
  9922.     bool bailout(void)
  9923.     {
  9924.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9925.     }
  9926.     void description(void)
  9927.     {
  9928.         this.title="gpm-sg302";
  9929.  
  9930.         p1.caption="Parameter 1";
  9931.         p1.default=(0.5,0.0);
  9932.    
  9933.  
  9934.         p2.caption="Parameter 2";
  9935.         p2.default=(1.0,0.0);
  9936.    
  9937.  
  9938.         bailout.caption="Bailout value";
  9939.         bailout.default=4.0;
  9940.    
  9941.  
  9942.         test.caption = "Bailout test";
  9943.         test.default = 0;
  9944.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  9945.         test.hint = "Original formula uses mod by default.";
  9946.    
  9947.  
  9948.         fn1.caption="Function 1";
  9949.         fn1.default = "cos" ;
  9950.   
  9951.  
  9952.         fn2.caption="Function 2";
  9953.         fn2.default = "ident" ;
  9954.   
  9955.  
  9956.         fn3.caption="Function 3";
  9957.         fn3.default = "flip" ;
  9958.   
  9959.  
  9960.         fn4.caption="Function 4";
  9961.         fn4.default = "ident" ;
  9962.   
  9963.     }
  9964. }
  9965.  
  9966.  
  9967. gpm-sg401     {//Sylvie Gallet's Gallet-4-01
  9968.                //translated to UF format and slightly modified by
  9969.                //Gedeon Peteri, December, 1999
  9970. complex h;
  9971. parameter complex p1;
  9972. complex a;
  9973. parameter complex p2;
  9974. complex Var_x;
  9975. complex Var_y;
  9976. complex x1;
  9977. complex y1;
  9978. parameter int test;
  9979. parameter real bailout;
  9980.  
  9981.     void init(void)
  9982.     {
  9983.         z=fn4(pixel);
  9984.         h=p1;
  9985.         a=p2;
  9986.     }
  9987.     void loop(void)
  9988.     {
  9989.         Var_x = real(z);
  9990.         Var_y = imag(z);
  9991.         x1 = Var_x - fn2(Var_x + a*fn1(Var_x+h));
  9992.         y1 = Var_y + fn2(Var_y + a*fn1(Var_y+h));
  9993.         z = x1 + fn3(y1);
  9994.     }
  9995.     bool bailout(void)
  9996.     {
  9997.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  9998.     }
  9999.     void description(void)
  10000.     {
  10001.         this.title="gpm-sg401";
  10002.  
  10003.         p1.caption="Parameter 1";
  10004.         p1.default=(0.3,0.0);
  10005.    
  10006.  
  10007.         p2.caption="Parameter 2";
  10008.         p2.default=(1.0,1.0);
  10009.    
  10010.  
  10011.         bailout.caption="Bailout value";
  10012.         bailout.default=4.0;
  10013.    
  10014.  
  10015.         test.caption = "Bailout test";
  10016.         test.default = 0;
  10017.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  10018.         test.hint = "Original formula uses mod by default.";
  10019.    
  10020.  
  10021.         fn1.caption="Function 1";
  10022.         fn1.default = "flip" ;
  10023.   
  10024.  
  10025.         fn2.caption="Function 2";
  10026.         fn2.default = "ident" ;
  10027.   
  10028.  
  10029.         fn3.caption="Function 3";
  10030.         fn3.default = "flip" ;
  10031.   
  10032.  
  10033.         fn4.caption="Function 4";
  10034.         fn4.default = "ident" ;
  10035.   
  10036.     }
  10037. }
  10038.  
  10039.  
  10040. gpm-sg402     {//Sylvie Gallet's Gallet-4-02
  10041.                //translated to UF format and slightly modified by
  10042.                //Gedeon Peteri, December, 1999
  10043. complex h;
  10044. parameter complex p1;
  10045. complex a;
  10046. parameter complex p2;
  10047. complex Var_x;
  10048. complex Var_y;
  10049. complex y1;
  10050. complex x1;
  10051. parameter int test;
  10052. parameter real bailout;
  10053.  
  10054.     void init(void)
  10055.     {
  10056.         z=fn4(pixel);
  10057.         h=p1;
  10058.         a=p2;
  10059.     }
  10060.     void loop(void)
  10061.     {
  10062.         Var_x = real(z);
  10063.         Var_y = imag(z);
  10064.         y1 = Var_y + fn2(Var_x + a*fn1(Var_x+h));
  10065.         x1 = Var_x - fn2(Var_y + a*fn1(Var_y+h));
  10066.         z = x1 + fn3(y1);
  10067.     }
  10068.     bool bailout(void)
  10069.     {
  10070.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  10071.     }
  10072.     void description(void)
  10073.     {
  10074.         this.title="gpm-sg402";
  10075.  
  10076.         p1.caption="Parameter 1";
  10077.         p1.default=(1.0,0.0);
  10078.    
  10079.  
  10080.         p2.caption="Parameter 2";
  10081.         p2.default=(0.5,0.0);
  10082.    
  10083.  
  10084.         bailout.caption="Bailout value";
  10085.         bailout.default=16.0;
  10086.    
  10087.  
  10088.         test.caption = "Bailout test";
  10089.         test.default = 0;
  10090.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  10091.         test.hint = "Original formula uses mod by default.";
  10092.    
  10093.  
  10094.         fn1.caption="Function 1";
  10095.         fn1.default = "ident" ;
  10096.   
  10097.  
  10098.         fn2.caption="Function 2";
  10099.         fn2.default = "log" ;
  10100.   
  10101.  
  10102.         fn3.caption="Function 3";
  10103.         fn3.default = "flip" ;
  10104.   
  10105.  
  10106.         fn4.caption="Function 4";
  10107.         fn4.default = "ident" ;
  10108.   
  10109.     }
  10110. }
  10111.  
  10112.  
  10113. gpm-sg604     {//Sylvie Gallet's Gallet-6-04
  10114.                //translated to UF format and slightly modified by
  10115.                //Gedeon Peteri, December, 1999
  10116. complex Var_x;
  10117. complex Var_y;
  10118. complex x1;
  10119. parameter complex p1;
  10120. parameter complex p2;
  10121. parameter complex p3;
  10122. complex y1;
  10123. parameter int test;
  10124. parameter real bailout;
  10125.  
  10126.     void init(void)
  10127.     {
  10128.         z=pixel;
  10129.         Var_x = real(z);
  10130.         Var_y = imag(z);
  10131.     }
  10132.     void loop(void)
  10133.     {
  10134.         x1 = Var_x - p1*fn1(Var_y + fn2(p2*Var_x) * fn3(p3*Var_y));
  10135.         y1 = Var_y - p1*fn1(Var_x + fn2(p2*Var_y) * fn3(p3*Var_x));
  10136.         Var_x = x1;
  10137.         Var_y = y1;
  10138.         z = Var_x + fn4(Var_y);
  10139.     }
  10140.     bool bailout(void)
  10141.     {
  10142.         return((test == 0 && |z| <= bailout) ||                                       (test == 1 && sqr(real(z)) <= bailout) ||                              (test == 2 && sqr(imag(z)) <= bailout) ||                              (test == 3 && (sqr(real(z)) <= bailout && sqr(imag(z)) < bailout)) || (test == 4 && (sqr(real(z)) <= bailout || sqr(imag(z)) < bailout)) || (test == 5 && (sqr(abs(real(z)) + abs(imag(z))) <= bailout)) ||        (test == 6 && (sqr(real(z) + imag(z)) <= bailout)));
  10143.     }
  10144.     void description(void)
  10145.     {
  10146.         this.title="gpm-sg604";
  10147.  
  10148.         p1.caption="Parameter 1";
  10149.         p1.default=(1.0,0.0);
  10150.    
  10151.  
  10152.         p2.caption="Parameter 2";
  10153.         p2.default=(1.0,0.0);
  10154.    
  10155.  
  10156.         p3.caption="Parameter 3";
  10157.         p3.default=(0.1,0.0);
  10158.    
  10159.  
  10160.         bailout.caption="Bailout value";
  10161.         bailout.default=32.0;
  10162.    
  10163.  
  10164.         test.caption = "Bailout test";
  10165.         test.default = 0;
  10166.         test.enum = "mod\nreal\nimag\nor\nand\nmanh\nmanr";
  10167.         test.hint = "Original formula uses mod by default.";
  10168.    
  10169.  
  10170.         fn1.caption="Function 1";
  10171.         fn1.default = "tan" ;
  10172.   
  10173.  
  10174.         fn2.caption="Function 2";
  10175.         fn2.default = "ident" ;
  10176.   
  10177.  
  10178.         fn3.caption="Function 3";
  10179.         fn3.default = "ident" ;
  10180.   
  10181.  
  10182.         fn4.caption="Function 4";
  10183.         fn4.default = "flip" ;
  10184.   
  10185.     }
  10186. }
  10187.  
  10188.  
  10189.