home *** CD-ROM | disk | FTP | other *** search
/ Media Share 13 / mediashare_13.zip / mediashare_13 / ZIPPED / GRAFX / OVERKILL.ZIP / OVERKILL.FRM < prev    next >
Text File  |  1994-04-10  |  11KB  |  442 lines
  1. comment {
  2.   This Fractint formula file is by Bradley Beacham, (c) April 1994.
  3.   I encourage you to copy and distribute it, but only if it is unaltered.
  4.   If you make changes to any of these formulas, please put your changes in
  5.   a new '.FRM' file.
  6.  
  7.   Early versions of most of these formulas have already been released in
  8.   either BLB.FRM or MONGO.FRM.  This file collects them in an improved
  9.   format and adds ten new formulas.
  10.  
  11.   The parameter file OVERKILL.PAR has many examples of the images I have
  12.   created with these formulas, as well as lots of other fractal types.
  13.   
  14.   I welcome any comments.  Reach me at:
  15.  
  16.     CIS: 74223,2745    Internet: 74223,2745@compuserve.com
  17.  
  18.     U.S. Mail: Bradley Beacham
  19.                1343 S. Tyler
  20.                Salt Lake City, Utah  84105
  21.                U.S.A.
  22.   
  23.   NOTE: You'll usually get more interesting results by using floating-point
  24.         math.  
  25. }
  26.  
  27. {-------------------------------------------------------------------------}
  28.  
  29. comment {
  30.   Earlier versions of the formulas OK-01 to OK-22 appeared in the file
  31.   BLB.FRM (June 1993), where they were named BLB-1 to BLB-22.  In these
  32.   'improved' versions, I added default values for any numeric parameters
  33.   you may supply, so you don't get a blank screen by leaving them at zero.
  34.  
  35.   These were my first attempts at inventing new formulas.  I basically used
  36.   the 'monkey-pounding-on-the-keyboard' technique, but still got some
  37.   interesting results.
  38. }
  39.  
  40. OK-01 { ;TRY P1 REAL = 10000, FN1 = SQR
  41.    z = 0, c = pixel:
  42.    z = (c^z) + c;
  43.    z = fn1(z),
  44.    |z| <= (5 + p1)
  45.   }
  46.  
  47. OK-02 { ;TRY FN1 = COTAN
  48.    z = c = pixel, k = 1 + p1:
  49.    z = (c^z) + c;
  50.    z = fn1(z) * k,
  51.    |z| <= (5 + p2)
  52.   }
  53.  
  54. OK-03 { ;TRY P1 REAL = 500, FN1 = COS, FN2 = SQR
  55.    z = c = pixel:
  56.    z = fn1(z)/c;
  57.    z = fn2(z),
  58.    |z| <= (5 + p1)
  59.   }
  60.  
  61. OK-04 { ;TRY FN2 = SQR, DIFFERENT FUNCTIONS FOR FN1
  62.    z = 0, c = fn1(pixel):
  63.    z = fn2(z) + c,
  64.    |z| <= (5 + p1)
  65.   }
  66.  
  67. OK-05 {
  68.    z = pixel, k = -2,2 + p1:
  69.    z = (z^k + z) / k,
  70.    (1 + p2) <= |z|
  71.   }
  72.  
  73. OK-06 { ;TRY FN1 = SQR, FN2 = SQR
  74.    z = c = pixel, d = fn1(pixel):
  75.    z = fn2(z / d) + c 
  76.    |z| <= (5 + p1)
  77.   }
  78.  
  79. OK-07 {
  80.    z = 0, c = pixel:
  81.    z = c * (z + c);
  82.    z = fn1(z + c),
  83.    |z| <= (5 + p1)
  84.   }
  85.  
  86. OK-08 {
  87.    z = pixel, c = fn1(pixel):
  88.    z = z^z / fn2(z);
  89.    z = c / z,
  90.    |z| <= (5 + p1)
  91.   }
  92.  
  93. OK-09 {
  94.    z = c = pixel, d = fn1(pixel), k = 1 + p1:
  95.    z = z^c * k;
  96.    z = d / z,
  97.    |z| <= (5 + p2)
  98.   }
  99.  
  100. OK-10 {
  101.    z = 0, c = pixel, k1 = 1 + p1, k2 = 1 + p2:
  102.    z = (z * k1) + c;
  103.    z = fn1(z) / (k2 + c),
  104.    |z| <= (k2)
  105.   }
  106.  
  107. OK-11 { ;TRY FN1 = SQR, FN2 = SQR
  108.    z = 0, v = pixel:
  109.    z = fn1(v) + z;
  110.    v = fn2(z) + v,
  111.    |z| <= (5 + p1)
  112.   }
  113.  
  114. OK-12 { ;TRY FN1 = SQR, FN2 = SQR
  115.    z = c = pixel:
  116.    z = fn1(z) + c;
  117.    z = fn2(z) / c,
  118.    |z| <= (5 + p1)
  119.   }
  120.  
  121. OK-13 { ;TRY FN1 = SQR, FN2 = SQR
  122.    z = 0, c = fn1(pixel) :
  123.    z = fn1(z) + c;
  124.    z = fn2(z),
  125.    |z| <= (5 + p1)
  126.   }
  127.  
  128. OK-14 { ;FOUR FUNCTIONS TO PLAY WITH HERE.  GO CRAZY.
  129.    z = 0, c = pixel :
  130.    z = fn1(z+c) + c;
  131.    z = fn2(z-c) + c;
  132.    z = fn3(z*c) + c;
  133.    z = fn4(z/c) + c,
  134.    |z| <= (5 + p1)
  135.   }
  136.  
  137. OK-15 {
  138.    z = 0, v = pixel :
  139.    z = fn1(v*z) + v;
  140.    v = fn2(v/z),
  141.    |z| <= (5 + p1)
  142.   }
  143.  
  144. OK-16 {
  145.    z = v = pixel :
  146.    z = fn1(z)^v;
  147.    v = v + z,
  148.    |z| <= (5 + p1)
  149.   }
  150.  
  151. OK-17 {
  152.    z = c = pixel, r = real(pixel), i = imag(pixel):
  153.    z = z^r + z^i + c;
  154.    z = z + real(fn1(z)) + imag(fn2(z)),
  155.    |z| <= (5 + p1)
  156.   }
  157.  
  158. OK-18 {
  159.    z = v = pixel:
  160.    z = fn1(v) + real(z);
  161.    v = fn2(z) + imag(v),
  162.    |z| <= (5 + p1)
  163.   }
  164.   
  165. OK-19 {
  166.    a = b = z = pixel:
  167.    a = fn1(b) + fn2(z);
  168.    b = fn1(z) + fn2(a);
  169.    z = fn1(a) + fn2(b),
  170.    |z| <= (5 + p1)
  171.   }
  172.  
  173. OK-20 {
  174.    a = b = c = z = pixel:
  175.    a = fn1(b) + c^z;
  176.    b = fn2(a+c);
  177.    z = z + (a * b * c),
  178.    |z| <= (5 + p1)
  179.   }
  180.  
  181. OK-21 {
  182.    z = pixel, c = fn1(pixel):
  183.    z = fn2(z) + c,
  184.    fn3(z) <= p1
  185.   }
  186.  
  187. OK-22 {
  188.    z = v = pixel:
  189.    v = fn1(v) * fn2(z);
  190.    z = fn1(z) / fn2(v),
  191.    |z| <= (5 + p1)
  192.   }
  193.  
  194. {-------------------------------------------------------------------------}
  195.  
  196. comment {
  197.   Earlier versions of the formulas OK-23 to OK-35 appeared in the file
  198.   MONGO.FRM (August 1993), where they were named MONGO-01 to MONGO-13.  In
  199.   these 'improved' versions, I added default values for any numeric
  200.   parameters you may supply, so you don't get a blank screen by leaving
  201.   them at zero.
  202.  
  203.   Most of these formulas are experiments with a crude sort of IF/ELSE
  204.   logic (an idea I swiped from Jon Osuch's SELECT.FRM) and produce images
  205.   with interesting discontinuities.
  206. }
  207.  
  208. OK-23 {
  209.    z = c = pixel, k = 1 + p1:
  210.    z = k * fn1(z^z + c) + c/z,
  211.    |z| <= (5 + p2)
  212.   }
  213.  
  214. OK-24 { ;TRY P1 REAL = -2, FN1 = SQR, FN2 = RECIP
  215.    z = 0, c = pixel, k = 1 + p1:
  216.    z = fn2(fn1(z) + c) + (k * z),
  217.    |z| <= (5 + p2)
  218.   }
  219.  
  220. OK-25 {
  221.    z = c = pixel, k = 1 + p1:
  222.    a = (abs(z) > k)  * (fn1(z) + c);
  223.    b = (abs(z) <= k) * (fn2(z) + c);
  224.    z = a + b,
  225.    |z| <= (5 + p2)
  226.   }
  227.  
  228. OK-26 {
  229.    z = c = pixel, k = 2 + p1, test = k/(2 + p2):
  230.    a = fn1(z);
  231.    b = (|z| > test)  * (a - c);
  232.    d = (|z| <= test) * (a + c);
  233.    z = b + d,
  234.    |z| <= k
  235.   }
  236.  
  237. OK-27 {
  238.    z = pixel, c = fn1(pixel), k = 1 + p1:
  239.    a = fn2(z);
  240.    b = (|z| >= k) * (a - c);
  241.    d = (|z| < k) * (a + c);
  242.    z = a + b + d,
  243.    |z| <= (10 + p2)
  244.   }
  245.  
  246. OK-28 {
  247.    z = c = pixel, d = fn1(pixel), k = p1:
  248.    a = fn2(z);
  249.    b = (z <= k) * (a + c + d);
  250.    e = (z > k) * (a + c - d);
  251.    z = z + b + e,
  252.    |z| <= (10 + p2)
  253.   }
  254.  
  255. OK-29 {
  256.    z = v = pixel, k = 1 + p1:
  257.    oldz = z;
  258.    z = fn1(z)^k + v;
  259.    v = oldz,
  260.    |z| <= (5 + p2)
  261.   }
  262.  
  263. OK-30 {
  264.    z = v = pixel, k = .5 + p1:
  265.    a = fn1(z);
  266.    b = (z <= k) * (a + v);
  267.    e = (z > k) * (a - v);
  268.    v = z;
  269.    z = b + e,
  270.    |z| <= (5 + p2)
  271.   }
  272.  
  273. OK-31 {
  274.    z = v = pixel, k = .1 + p1:
  275.    a = fn1(z);
  276.    b = (a <= k) * (a + v);
  277.    e = (a > k) * fn2(a);
  278.    v = z;
  279.    z = b + e,
  280.    |z| <= (5 + p2)
  281.   }
  282.  
  283. OK-32 {
  284.    z = y = x = pixel, k = 1 + p1:
  285.    a = fn1(z);
  286.    b = (a <= y) * ((a * k) + y);
  287.    e = (a > y) * ((a * k) + x);
  288.    x = y;
  289.    y = z;
  290.    z = b + e,
  291.    |z| <= (5 + p2)
  292.   }
  293.  
  294. OK-33 {
  295.    z = y = x = pixel, k = 1 + p1:
  296.    a = (|y| <= k) * fn1(y);
  297.    b = (|x| <= k) * fn2(x);
  298.    x = y;
  299.    y = z;
  300.    z = fn3(z) + a + b,
  301.    |z| <= (10 + p2)
  302.   }
  303.  
  304. OK-34 {
  305.    z = pixel, c = (fn1(pixel) * p1):
  306.    x = abs(real(z));
  307.    y = abs(imag(z));
  308.    a = (x <= y) * (fn2(z) + y + c);
  309.    b = (x > y) * (fn2(z) + x + c);
  310.    z = a + b,
  311.    |z| <= (10 + p2)
  312.   }
  313.  
  314. OK-35 {
  315.    z = pixel, k = 1 + p1:
  316.    v = fn1(z);
  317.    x = (z*v);
  318.    y = (z/v);
  319.    a = (|x| <= |y|) * ((z + y) * k);
  320.    b = (|x| > |y|) * ((z + x) * k);
  321.    z = fn2((a + b) * v) + v,
  322.    |z| <= (10 + p2)
  323.   }
  324.  
  325. {-------------------------------------------------------------------------}
  326.  
  327. comment {
  328.   The remaining formulas, OK-36 to OK-45, are new to OVERKILL.FRM.  Some of
  329.   these formulas use an approach I call 'disection' (for lack of a better
  330.   term), and were inspired by a nifty CD-ROM called "Fractal Ecstasy".
  331.   (It's made by Deep River Publishing.)
  332.  
  333.   Anyway, the idea is to calculate the real and imaginary parts of complex
  334.   numbers separately using standard algebra.  The advantage is that
  335.   variables and functions can be applied in ways that would be difficult
  336.   using the conventional approach.  The disadvantage is that the formula is
  337.   more complicated.
  338.  
  339.   Suggestion:  When you experiment with the 'disected' formulas, start by
  340.   setting all functions to IDENT.  Then change one or two of the parameters
  341.   at a time.
  342. }
  343.  
  344. OK-36 { ; DISECTED MANDELBROT
  345.   ; TO GENERATE "STANDARD" MANDELBROT, SET P1 = 0,0 & ALL FN = IDENT
  346.   z = pixel, cx = fn1(real(z)), cy = fn2(imag(z)), k = 2 + p1:
  347.   zx = real(z), zy = imag(z);
  348.   x = fn3(zx*zx - zy*zy) + cx;
  349.   y = fn4(k * zx * zy) + cy;
  350.   z = x + flip(y),
  351.   |z| <  (10 + p2)
  352. }
  353.  
  354. OK-37 { ; ANOTHER DISECTED MANDELBROT
  355.   ; TO GENERATE "STANDARD" MANDELBROT, SET P1 = 0,0 & ALL FN = IDENT
  356.   z = pixel, c = fn1(fn2(z)), cx = real(c), cy = imag(c), k = 2 + p1:
  357.   zx = fn3(real(z)), zy = fn4(imag(z));
  358.   x = zx*zx - zy*zy + cx;
  359.   y = k * zx * zy + cy;
  360.   z = x + flip(y),
  361.   |z| <  (10 + p2)
  362. }
  363.  
  364. OK-38 { ; DISECTED CUBIC MANDELBROT
  365.   ; TO GENERATE "STANDARD" CUBIC MANDELBROT, SET P1 = 0,0 & ALL FN = IDENT
  366.   z = pixel,  cx = fn1(real(pixel)), cy = fn2(imag(pixel)), k = 3 + p1:
  367.   zx = real(z), zy = imag(z);
  368.   x = fn3(zx*zx*zx - k*zx*zy*zy) + cx;
  369.   y = fn4(k*zx*zx*zy - zy*zy*zy) + cy;
  370.   z =  x + flip(y),
  371.   |z| <  (4 + p2)
  372. }
  373.  
  374. OK-39 { ; JUST AN EXPERIMENT
  375.   z = pixel, c = fn1(z), k = p1:
  376.   z = fn2(z*c + k) + c,
  377.   |z| <= (20 + p2)
  378.  }
  379.  
  380. OK-40 { ; DISECTED OK-39
  381.   ; (ASSUMING YOU USE OK-39 WITH FN1= IDENT & FN2 = SQR...)
  382.   z = pixel, cx = fn1(real(pixel)), cy = fn2(imag(pixel)), k = 2 + p1:
  383.   zx = real(z), zy = imag(z);
  384.   a = zx*cx - zy*cy;
  385.   b = cx*zy + zx*cy;
  386.   x = fn3(a*a - b*b) + cx;
  387.   y = fn4(k*a*b) + cy;
  388.   z = x + flip(y),
  389.   |z| <= (10 + p2)
  390. }
  391.  
  392. OK-41 { ; DISECTED MANDELLAMBDA
  393.   z = 0.5 + p1, lx = fn1(real(pixel)), ly = fn2(imag(pixel)):
  394.   zx = real(z), zy = imag(z);
  395.   x = fn3(lx*zx + 2*ly*zx*zy - ly*zy - lx*zx*zx + lx*zy*zy);
  396.   y = fn4(ly*zx - 2*lx*zx*zy + lx*zy - ly*zx*zx + ly*zy*zy);
  397.   z = x + flip(y),
  398.   |z| <= (10 + p2)
  399. }
  400.  
  401. OK-42 { ; MUTATION OF FN + FN
  402.   z = pixel, p1x = real(p1)+1, p1y = imag(p1)+1,
  403.   p2x = real(p2)+1, p2y = imag(p2)+1:
  404.   zx = real(z), zy = imag(z);
  405.   x = fn1(zx*p1x - zy*p1y) + fn2(zx*p2x - zy*p2y);
  406.   y = fn3(zx*p1y + zy*p1x) + fn4(zx*p2y + zy*p2x);
  407.   z = x + flip(y),
  408.   |z| <= 20
  409. }
  410.  
  411. OK-43 { ; DISECTED SPIDER
  412.   ; TO GENERATE "STANDARD" SPIDER, SET P1 = 0,0 & ALL FN = IDENT
  413.   z = c = pixel, k = 2 + p1:
  414.   zx = real(z), zy = imag(z);
  415.   cx = real(c), cy = imag(c);
  416.   x = fn1(zx*zx - zy*zy) + cx;
  417.   y = fn2(k*zx*zy) + cy;
  418.   z = x + flip(y);
  419.   c = fn3((cx + flip(cy))/k) + z,
  420.   |z| <  (10 + p2)
  421. }
  422.  
  423. OK-44 { ; DISECTED MANOWAR
  424.   ; TO GENERATE "STANDARD" MANOWAR, SET P1 = 0,0 & ALL FN = IDENT
  425.   z = pixel, z1x = cx = real(pixel), z1y = cy = imag(pixel),
  426.   k = 2 + p1:
  427.   oldzx = zx = real(z), oldzy = zy = imag(z);
  428.   x = fn1(zx*zx - zy*zy) + fn2(z1x) + cx;
  429.   y = fn3(k*zx*zy) + fn4(z1y) + cy;
  430.   z = x + flip(y);
  431.   z1x = oldzx, z1y = oldzy,
  432.   |z| <= (10 + p2)
  433. }
  434.  
  435. OK-45 { ; ANOTHER LITTLE QUICKY
  436.   z = pixel, c = fn1(pixel), ka = 1 + p1, kb = 1 + p2:
  437.   a = fn2(z), b = fn3(z);
  438.   z = ka*a*a*a + kb*b*b + c,
  439.   |z| <= 10
  440.  }
  441.  
  442.