home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 November / Chip_2001-11_cd1.bin / sharewar / chaospro / cpro302.exe / LKM-SPECIAL.CFM < prev    next >
Encoding:
Text File  |  2001-09-03  |  4.6 KB  |  306 lines
  1. comment {
  2.  
  3. Special calculation formulas developed by Kerry Mitchell
  4.  
  5. Note! These are experimental, beta tests, highly specialized,
  6. or worse. Not for the faint of heart or new to UF. In general,
  7. there's little to no support or documentation. In short, you're
  8. on your own.
  9.  
  10. Have fun! :-)
  11. }
  12.  
  13.  
  14. aug01-transcendental-mandelbrot2 {
  15. complex c;
  16. parameter complex manparam;
  17. parameter int functype;
  18. bool done;
  19. real r;
  20. parameter real bailout;
  21.  
  22.     void init(void)
  23.     {
  24.         c=pixel;
  25.         if ((cabs(manparam)==0.0))
  26.         {
  27.             if ((functype==1))
  28.             {// exp(z)*c
  29.                 z=0;
  30.             }
  31.             else if ((functype==2))
  32.             {// sin(z)+c
  33.                 z=c+1;
  34.             }
  35.             else if ((functype==3))
  36.             {// sin(z)*c
  37.                 z=c;
  38.             }
  39.             else if ((functype==4))
  40.             {// cos(z)+c
  41.                 z=c+1;
  42.             }
  43.             else if ((functype==5))
  44.             {// cos(z)*c
  45.                 z=c;
  46.             }
  47.             else if ((functype==6))
  48.             {// tan(z)+c
  49.                 z=c+(0,1);
  50.             }
  51.             else if ((functype==7))
  52.             {// tan(z)*c
  53.                 z=c*(0,1);
  54.             }
  55.             else
  56.             {
  57.                      // exp(z)+c
  58.                 z=c;
  59.             }
  60.         }
  61.         else
  62.         {
  63.  
  64.             z=manparam;
  65.         }
  66.         done=false;
  67.         r=0.0;
  68.     }
  69.     void loop(void)
  70.     {
  71.         if ((functype==1))
  72.         {// exp(z)*c
  73.             z=exp(z)*c;
  74.             r=real(z);
  75.             if ((r>bailout))
  76.             {
  77.                 done=true;
  78.             }
  79.         }
  80.         else if ((functype==2))
  81.         {// sin(z)+c
  82.             z=sin(z)+c;
  83.             r=abs(imag(z));
  84.             if ((r>bailout))
  85.             {
  86.                 done=true;
  87.             }
  88.         }
  89.         else if ((functype==3))
  90.         {// sin(z)*c
  91.             z=sin(z)*c;
  92.             r=abs(imag(z));
  93.             if ((r>bailout))
  94.             {
  95.                 done=true;
  96.             }
  97.         }
  98.         else if ((functype==4))
  99.         {// cos(z)+c
  100.             z=cos(z)+c;
  101.             r=abs(imag(z));
  102.             if ((r>bailout))
  103.             {
  104.                 done=true;
  105.             }
  106.         }
  107.         else if ((functype==5))
  108.         {// cos(z)*c
  109.             z=cos(z)*c;
  110.             r=abs(imag(z));
  111.             if ((r>bailout))
  112.             {
  113.                 done=true;
  114.             }
  115.         }
  116.         else if ((functype==6))
  117.         {// tan(z)+c
  118.             z=tan(z)+c;
  119.             r=cabs(z);
  120.             if ((r>bailout))
  121.             {
  122.                 done=true;
  123.             }
  124.         }
  125.         else if ((functype==7))
  126.         {// tan(z)*c
  127.             z=tan(z)*c;
  128.             r=cabs(z);
  129.             if ((r>bailout))
  130.             {
  131.                 done=true;
  132.             }
  133.         }
  134.         else
  135.         {
  136.                        // exp(z)+c
  137.             z=exp(z)+c;
  138.             r=real(z);
  139.             if ((r>bailout))
  140.             {
  141.                 done=true;
  142.             }
  143.         }
  144.     }
  145.     bool bailout(void)
  146.     {
  147.         return(done==false);
  148.     }
  149.     void description(void)
  150.     {
  151.         this.title="Transcendental Mandelbrot2";
  152.         this.maxiter=100;
  153.         this.center=(0,0);
  154.         this.magn=0.25;
  155.         this.periodicity=0;
  156.         this.method="multipass";
  157.    
  158.         manparam.caption="initial z";
  159.         manparam.default=(0,0);
  160.         manparam.hint="Use (0,0) for critical point.";
  161.   
  162.    
  163.         bailout.caption="bailout";
  164.         bailout.default=16.0;
  165.         bailout.min=0.0;
  166.   
  167.    
  168.         functype.caption="function type";
  169.         functype.default=0;
  170.         functype.enum="exp(z)+c\nexp(z)*c\nsin(z)+c\nsin(z)*c\ncos(z)+c\ncos(z)*c\ntan(z)+c\ntan(z)*c";
  171.   
  172.  
  173.   
  174.   
  175.   
  176.   
  177.     }
  178. }
  179.  
  180.  
  181. aug01-transcendental-julia2 {
  182. complex c;
  183. parameter complex julparam;
  184. bool done;
  185. real r;
  186. parameter int functype;
  187. parameter real bailout;
  188.  
  189.     void init(void)
  190.     {
  191.         z=pixel;
  192.         c=julparam;
  193.         done=false;
  194.         r=0.0;
  195.     }
  196.     void loop(void)
  197.     {
  198.         if ((functype==1))
  199.         {// exp(z)*c
  200.             z=exp(z)*c;
  201.             r=real(z);
  202.             if ((r>bailout))
  203.             {
  204.                 done=true;
  205.             }
  206.         }
  207.         else if ((functype==2))
  208.         {// sin(z)+c
  209.             z=sin(z)+c;
  210.             r=abs(imag(z));
  211.             if ((r>bailout))
  212.             {
  213.                 done=true;
  214.             }
  215.         }
  216.         else if ((functype==3))
  217.         {// sin(z)*c
  218.             z=sin(z)*c;
  219.             r=abs(imag(z));
  220.             if ((r>bailout))
  221.             {
  222.                 done=true;
  223.             }
  224.         }
  225.         else if ((functype==4))
  226.         {// cos(z)+c
  227.             z=cos(z)+c;
  228.             r=abs(imag(z));
  229.             if ((r>bailout))
  230.             {
  231.                 done=true;
  232.             }
  233.         }
  234.         else if ((functype==5))
  235.         {// cos(z)*c
  236.             z=cos(z)*c;
  237.             r=abs(imag(z));
  238.             if ((r>bailout))
  239.             {
  240.                 done=true;
  241.             }
  242.         }
  243.         else if ((functype==6))
  244.         {// tan(z)+c
  245.             z=tan(z)+c;
  246.             r=cabs(z);
  247.             if ((r>bailout))
  248.             {
  249.                 done=true;
  250.             }
  251.         }
  252.         else if ((functype==7))
  253.         {// tan(z)*c
  254.             z=tan(z)*c;
  255.             r=cabs(z);
  256.             if ((r>bailout))
  257.             {
  258.                 done=true;
  259.             }
  260.         }
  261.         else
  262.         {
  263.                        // exp(z)+c
  264.             z=exp(z)+c;
  265.             r=real(z);
  266.             if ((r>bailout))
  267.             {
  268.                 done=true;
  269.             }
  270.         }
  271.     }
  272.     bool bailout(void)
  273.     {
  274.         return(done==false);
  275.     }
  276.     void description(void)
  277.     {
  278.         this.title="Transcendental Julia2";
  279.         this.maxiter=100;
  280.         this.center=(0,0);
  281.         this.magn=0.25;
  282.         this.periodicity=0;
  283.         this.method="multipass";
  284.    
  285.         julparam.caption="Julia parameter";
  286.         julparam.default=(1,1);
  287.   
  288.    
  289.         bailout.caption="bailout";
  290.         bailout.default=16.0;
  291.         bailout.min=0.0;
  292.   
  293.    
  294.         functype.caption="function type";
  295.         functype.default=0;
  296.         functype.enum="exp(z)+c\nexp(z)*c\nsin(z)+c\nsin(z)*c\ncos(z)+c\ncos(z)*c\ntan(z)+c\ntan(z)*c";
  297.   
  298.  
  299.   
  300.   
  301.   
  302.     }
  303. }
  304.  
  305.  
  306.