home *** CD-ROM | disk | FTP | other *** search
/ Computerworld 1996 March / Computerworld_1996-03_cd.bin / idg_cd3 / grafika / fraktaly / fractxtr / frm / noel.frm < prev    next >
Text File  |  1994-12-25  |  20KB  |  675 lines
  1. ;  also see noel.par
  2. ;
  3. ; FRACTAL FORMULA FILE FROM NOEL GIFFIN  "noel@.triumf.ca"
  4. ; =====================================================================
  5. ;    These fractal formula are all based on the same principal, which I
  6. ; refer to as "induction" or as a family, as "inductive fractals".
  7. ; The basic concept is that of using previous terms in the iterative
  8. ; loop to introduce a new dynamic.  As a class, they are all complex
  9. ; deterministic equations similar to the classic mandelbrot, but use
  10. ; these inductive or self-referential techniques. They are a little
  11. ; finicky as they don't like some of fractints default options.
  12. ; They don't like fractint's periodicity checking so make sure it's off.
  13. ; Use the command line version as just setting it to zero from the menu
  14. ; isn't good enough. Also many will not compute well if your using
  15. ; boundary tracing methods, as there are a lot of local fractal areas
  16. ; disconnected from the main set. They tend not to be locally connected
  17. ; like the mandelbrot. Boundary tracing tends to wash over these areas.
  18. ; Also The tessaral and solid guessing techniques can cause problems
  19. ; for similar reasons only it isn't quite as severe.
  20. ;
  21. ;    The formula are presented in a loose chronological sequence showing
  22. ; the logical order of development. I have litely annotated each
  23. ; equation so that you may follow the trends in my exploration.
  24. ; Feel free to take them where you will. If you encorporate them in
  25. ; other programs or remove them from this file than I would appreciate a
  26. ; reference.
  27. ;
  28. ;    There are a lot of variants for the HT formula here toward the end
  29. ; of the file. It's a formula type that I have been playing with
  30. ; recently. It basically takes a passed parameter as a constant and uses
  31. ; it as a scaling factor on the feedback from previous terms. Similar
  32. ; to digital filtering techniques. I usually use it with an inversion
  33. ; as this tends to cause a see-saw dynamic and only runs to infinity
  34. ; when things get really chaotic. At least I think thats what's
  35. ; happening.
  36. ;
  37. ;    At the very end I've included a few fractal freaks and misfits for
  38. ; laughs and general amusement.
  39. ;                                   Enjoy,
  40. ;                                   Noel Giffin
  41. ;                                   noel@reg.triumf.ca
  42. ; =====================================================================
  43.  
  44.  hydra(XAXIS) {
  45.  ; The first inductive formula I came up with.
  46.       z = pixel, zp = (0,0):
  47.          temp = z
  48.          z = z*z + zp
  49.          zp = temp, |zp| <= 4 }
  50.  
  51.  
  52.  trillium(XAXIS)  {
  53.  ; A minor variation in sign will produce a remarkable change
  54.       z = pixel, zp = (0,0):
  55.          temp = z
  56.            z = z*z - zp
  57.            zp = temp,  |zp| <= 4 }
  58.  
  59.  octo(XYAXIS)  {
  60. ; The next obvious thing to try is different powers
  61. ; Note. Changing sign in this one like the trillium only rotates 22.5 deg.
  62.       z = pixel,zp=(0,0):
  63.       temp = z
  64.       z = z^3 + zp
  65.       zp = temp, |zp| <= 4 }
  66.  
  67.  penta(XAXIS)  {
  68. ; introducing a second function can add lots of variety.
  69.         z = pixel, zp = (0,0):
  70.           temp = z
  71.           z = z*z - zp
  72.           zp = conj(temp),|zp| <= 4 }
  73.  
  74.  star(XAXIS)  {
  75. ; Changing the sign back makes a simple but elegent fractal
  76.         z=pixel, zp = (0,0):
  77.           temp = z
  78.           z = z*z + zp
  79.           zp = conj(temp),|zp| <= 64 }
  80.  
  81. penta2(XAXIS)  {
  82. ; A simple technique of changing init params to map to a function.
  83.         z = pixel^2, zp = (0,0):
  84.           temp = z
  85.           z = z*z - zp
  86.           zp = conj(temp),|zp| <= 4 }
  87.  
  88.  hsqr(XYAXIS)  {
  89. ; squaring the initialized value of the hydra fractal
  90.       z = pixel^2,zp=(0,0):
  91.       temp = z
  92.       z = z*z +  zp
  93.       zp = temp, |zp| <= 4 }
  94.  
  95.  hroot(XAXIS)  {
  96. ; Map hydra function to the Square root of the pixel value.
  97.       z = pixel^0.5,zp=(0,0):
  98.       temp = z
  99.       z = z*z +  zp
  100.       zp = temp, |zp| <= 4 }
  101.  
  102. frog(XAXIS)  {
  103. ; What happens if you take a root of what you just squared and summed?
  104.         z=pixel, zp = (0,0):
  105.           temp = z
  106.           z = z*z + zp
  107.           zp = temp^.5,|zp| <= 4 }
  108.  
  109.  kilroy(XAXIS)  {
  110. ; The sign change trick makes a small change here
  111.         z=pixel, zp = (0,0):
  112.           temp = z
  113.           z = z*z - zp
  114.           zp = (temp)^.5,|zp| <= 4 }
  115.  
  116.  four(XYAXIS)  {
  117. ; A square root initialization of the octo will halve the number of arms
  118.       z = pixel^.5,zp=(0,0):
  119.       temp = z
  120.       z = z^3 - zp
  121.       zp = temp, |zp| <= 4 }
  122.  
  123.  goat(XAXIS)  {
  124. ; What about a root of the negative sum?
  125.        z = pixel, zp = (0,0):
  126.           temp = z
  127.           z = z*z + zp
  128.           zp = (-temp)^.5,|zp| <= 4 }
  129.  
  130.  quatro(XYAXIS)  {
  131. ; Forget the squared term and iterate a trig function
  132.         z=pixel, zp = (0,0):
  133.           temp = z
  134.           z = sin(z) - zp
  135.           zp = temp,|zp| <= 4 }
  136.  
  137.  peacock(XAXIS)  {
  138. ; The next obvious function to try
  139.       z = pixel, zp = (0,0):
  140.       temp = z
  141.       z = -cos(z) - zp
  142.       zp = temp, |zp| <= 4 }
  143.  
  144.  globe(XAXIS)  {
  145. ; Will it work with just a square root?
  146.       z = pixel, zp = (0,0):
  147.       temp = z
  148.       z = z^.5 - zp
  149.       zp = temp, |zp| <= 4 }
  150.  
  151.  clips(XAXIS)  {
  152. ; A rather bizzare varient made with a sign change.
  153.       z = pixel, zp = (0,0):
  154.       temp = z
  155.       z = -(z^.5) - zp
  156.       zp = temp, |zp| <= 4 }
  157.  
  158.  clipover(XAXIS)  {
  159. ; Lets turn it inside out like the mandover mapping.
  160.       z =1/pixel, zp = (0,0):
  161.       temp = z
  162.       z = -(z^.5) - zp
  163.       zp = temp, |zp| <= 4 }
  164.  
  165.  psycho(XAXIS)  {
  166. ;  Another nice two function variation
  167.       z = pixel, zp = (0,0):
  168.       temp = z
  169.       z = z*z - zp
  170.       zp = sin(-temp), |zp| <= 4 }
  171.  
  172.  exp1(XAXIS)  {
  173. ; An exponential function can produce fractals as well
  174.       z = pixel, zp = (0,0):
  175.       temp = z
  176.       z = -exp(z) - zp
  177.       zp = temp, |zp| <= 4 }
  178.  
  179.  frtan(XAXIS)  {
  180. ; Lets not forget the tangent
  181.       z = pixel, zp = (0,0):
  182.       temp = z
  183.       z = -tan(z) - zp
  184.       zp = temp, |zp| <= 4 }
  185.  
  186.  fish(XAXIS)  {
  187. ; Lets not completely rule out a constant either. Add one to the Trillium
  188.         z=c=pixel, zp = (0,0):
  189.           temp = z
  190.           z = z*z - zp + c
  191.           zp = temp,|zp| <= 4 }
  192.  
  193.  septo(XAXIS)  {
  194. ; We can save and use more than just the previous term
  195.       z = pixel, zp1 = zp2 = (0,0):
  196.       temp = z
  197.       z = z*z - zp2
  198.       zp2 = zp1
  199.       zp1 = temp,  |zp1| <= 4 }
  200.  
  201.  pheonix(XAXIS)  {
  202. ; Add conjugation and produce a great fractal even if it's spelt wrong.
  203.       z = pixel, zp1 = zp2 = (0,0):
  204.       temp = z
  205.       z  = z*z - zp2
  206.       zp2 = zp1
  207.       zp1 = conj(temp), |zp1| <= 4 }
  208.  
  209.  pheonabs(XAXIS)  {
  210. ; A pheonix variant
  211.       z = pixel, zp1 = zp2 = (0,0):
  212.       temp = z
  213.       z  = z*z - abs(zp2)
  214.       zp2 = zp1
  215.       zp1 = conj(temp), |zp1| <= 4 }
  216.  
  217.  pheon2(XAXIS)  {
  218. ; A square root mapping of the pheonix. Interesting because of the
  219. ; discontinuites introduced in the folded symmetry.
  220.       z = pixel^.5, zp1 = zp2 = (0,0):
  221.       temp = z
  222.       z  = z*z - zp2
  223.       zp2 = zp1
  224.       zp1 = conj(temp), |zp1| <= 4 }
  225.  
  226.  cntrpc(XYAXIS)  {
  227. ; another interesting variant using two previous terms.
  228.       z = zp1 = pixel, zp2 = (0,0):
  229.       temp = z
  230.       z  = z * zp1 - zp2
  231.       zp2 = zp1
  232.       zp1 = temp, |zp1| <= 4 }
  233.  
  234.  cntr1(XAXIS)  {
  235. ; There are many different combinations on this theme.
  236.       z = zp1 = zp2 = pixel:
  237.       temp = z
  238.       z  = z * zp2 + zp1
  239.       zp2 = zp1
  240.       zp1 = temp, |zp1| <= 4 }
  241.  
  242.  
  243.  bfly(XYAXIS)  {
  244. ; Be creative and try to use these terms in novel ways.
  245. ; You have to be careful what you initialize here
  246. ; or everything goes to 0.0
  247.       z = zp1 = pixel, zp2 = (0,0):
  248.       temp = z
  249.       z  = z * zp1 + zp2
  250.       zp2 = zp1
  251.       zp1 = temp, |zp1| <= 4 }
  252.  
  253.  bfly1(XAXIS)  {
  254. ; A minor variation on exp1 [init to pixel], gives another
  255. ; butterfly symmetry.
  256.       z = zp = pixel:
  257.       temp = z
  258.       z = -exp(z) - zp
  259.       zp = temp, |zp| <= 4 }
  260.  
  261.  bfly2(XAXIS)  {
  262. ; Try a minor real axis offset in the iterative loop.
  263.         z=pixel, zp = (0,0):
  264.           temp = z
  265.           z = 1-exp(z) - zp
  266.           zp = temp,|zp| <= 4 }
  267.  
  268.  exp2(XAXIS)  {
  269. ; Init both terms to pixel ala bfly1 etc...
  270.         z=zp=pixel:
  271.           temp = z
  272.           z = 1-exp(-z) - zp
  273.           zp = temp,|zp| <= 4 }
  274.  
  275.  
  276.  bfly3(XAXIS)  {
  277. ; How about a conjugation of a cosine function
  278.         z=pixel, zp = z1 = (0,0):
  279.           temp = z
  280.           z = 1-cos(z) - zp
  281.           zp = conj(temp),|zp| <= 4 }
  282.  
  283.  crown(XAXIS)  {
  284. ; some interesting combinations make some wierd formations.
  285.       z = zp1 = pixel, zp2 = (0,0):
  286.       temp = z
  287.       z = z*zp2 - zp1
  288.       zp2 = zp1^.5
  289.       zp1 = temp,  |zp1| <= 4 }
  290.  
  291.  nigel(XAXIS)  {
  292. ; If we keep adding terms the symmetry order goes even higher
  293.       z = pixel,zp1=zp2=zp3=(0,0):
  294.       temp = z
  295.       z = z*z - zp3
  296.       zp3 = zp2
  297.       zp2 = zp1
  298.       zp1 = temp, |zp1| <= 4 }
  299.  
  300.  cnigel(XAXIS)  {
  301. ; Conjugates still show the chaotic banding it tends to
  302. ; produce in this fractal type.
  303.       z = pixel,zp1=zp2=zp3=(0,0):
  304.       temp = z
  305.       z = z*z - zp3
  306.       zp3 = zp2
  307.       zp2 = zp1
  308.       zp1 = conj(temp), |zp1| <= 4 }
  309.  
  310.  hflip  {
  311. ; A little non-standard math-function produces chaotic bands like the
  312. ; conjugate function but the symmetry is now skew.
  313.       z = pixel,zp=(0,0):
  314.       temp = z
  315.       z = z*z +  zp
  316.       zp = flip(temp), |zp| <= 4 }
  317.  
  318.  hflip2  {
  319. ; The pixel squared mapping still doubles the symmetry.
  320.       z = pixel^2,zp=(0,0):
  321.       temp = z
  322.       z = z*z +  zp
  323.       zp = flip(temp), |zp| <= 4 }
  324.  
  325.  royal1(XYAXIS)  {
  326. ; Coupling conjugate functions with others produce some nice variants.
  327.       z = pixel,  zp = (0,0):
  328.       temp = z
  329.       z = z*z  - cos(zp)
  330.       zp = conj(temp), |zp| <= 4 }
  331.  
  332.  royal2(XYAXIS)  {
  333. ; Yet another Conjugate variation
  334.       z = pixel, zp2 = zp1 = (0,0):
  335.       temp = z
  336.       z = z*z  - zp2
  337.       zp2 = cos(zp1)
  338.       zp1 = conj(temp), |zp1| <= 4}
  339.  
  340.  three(XAXIS)  {
  341. ; A very different idea. Don't use the current value, just previous ones.
  342. ; You still have to save it of course.
  343.       z = pixel,  zp1 = zp2 = (0,0):
  344.       temp = z
  345.       z = zp2*zp2  - zp1
  346.       zp2 = zp1
  347.       zp1 = temp, |zp1| <= 4}
  348.  
  349.  tree(XAXIS)  {
  350. ; Try a different order of the terms.
  351.       z = pixel,  zp1 = zp2 = (0,0):
  352.       temp = z
  353.       z = zp1*zp1  - zp2
  354.       zp2 = zp1
  355.       zp1 = temp, |zp1| <= 4 }
  356.  
  357.  scorpio(XAXIS)  {
  358. ;  Throw in a second function and things get interesting again
  359.       zp1 = zp2 = pixel, z = (0,0):
  360.       temp = z
  361.       z = zp1*zp1 - zp2
  362.       zp2 = zp1
  363.       zp1 = sin(temp), |zp1| <= 4}
  364.  
  365.  trick(XAXIS)  {
  366. ; An different method to work in a second function
  367.       z = pixel, zp = (0,0):
  368.          temp = z
  369.            z = sin(z)*z - zp
  370.            zp = (temp),  |zp| <= 4 }
  371.  
  372.  logf  {
  373. ; I never did work with logs that much but this one was interesting.
  374.         z=pixel, zp = (0,0):
  375.           temp = z
  376.           z = z*z + zp
  377.           zp = log(1-temp),|zp| <= 4 }
  378.  
  379.  xxx  {
  380. ; Use the previous term as an exponent and see what happens
  381. ; Not particularly interesting but here for completeness and showing
  382. ; the development path.
  383.       z = zp1 = pixel, zp2 = (0,0):
  384.       temp = z
  385.       z = z^zp1 - zp2
  386.       zp2 = zp1
  387.       zp1 = temp, |zp1| <= 4}
  388.  
  389.  zzz(XAXIS)  {
  390. ; Same as XXX but introduce a new dynamic by inverting a previous term
  391. ; A small but curious active region. Try 256 colour decomp.
  392.       z = zp1 = pixel, zp2 = (0,0):
  393.       temp = z
  394.       z = z^zp1 - zp2
  395.       zp2 = zp1
  396.       zp1 = 1/temp, |zp1| <= 4}
  397.  
  398.  yyy(XAXIS) {
  399. ; Try Zprev to the power Zed (the reverse of the ZZZ function
  400. ; This formula doesn't seem to work the same in fractint vers > 17.2
  401. ; I haven't figured out why yet but what should be inside, isn't anymore.
  402. ; It doesn't change the structure, just the colouring.
  403.       z = zp1 = pixel, zp2 = (0,0):
  404.       temp = z
  405.       z = zp1^z - zp2
  406.       zp2 = zp1
  407.       zp1 = 1/temp, |zp1| <= 4}
  408.  
  409.  zz2 (XAXIS) {
  410.  ; Try the inversion again
  411.       z = zp1 = pixel, zp2 = (0,0):
  412.       temp = z
  413.       z = z^zp2 - zp1
  414.       zp2 = zp1
  415.       zp1 = 1/temp, |zp1| <= 4}
  416.  
  417.  yy2 (XAXIS) {
  418. ; This formula doesn't seem to work the same in fractint vers > 17.2
  419. ; I haven't figured out why yet but what should be inside, isn't anymore.
  420. ; Might be a new fractint bug or perhaps a side effect from a bugfix.
  421.       z = zp1 = pixel, zp2 = (0,0):
  422.       temp = z
  423.       z = zp1^z - zp2
  424.       zp2 = zp1
  425.       zp1 = 1/temp, |zp2| <= 4}
  426.  
  427.  texp1 (XAXIS) {
  428. ; Lets try a different constant with a non-zero imaginary component
  429.       z = pixel, c = (1.5,0.5), zp = (0,0):
  430.       temp = z
  431.       z = -exp(z) - zp
  432.       zp = c/temp, |zp| <= 4 }
  433.  
  434.  ht1 {
  435. ; Ah! You can use a variable in the inversion but now check for overflow.
  436. ; Good results are found when the real part of p1 is in the range 0.1->1.0
  437. ; With some sort of special value aprox. 0.148148...
  438. ; Setting the imaginary part as well causes very strange fractals
  439.       z = pixel,zp=temp=(0,0),huge=1.0e32:
  440.       temp = z
  441.       z = z*z + zp
  442.       zp = p1/temp, (|zp| <= 64) && (|z| <= huge) }
  443.  
  444.  htc {
  445. ; You can do it with a constant too.
  446.       z = c = pixel,zp=(0,0),huge=1.0e32:
  447.       temp = z
  448.       z = z*z + zp
  449.       zp = c*p1/temp, (|zp| <= 64) && (|z| <= huge) }
  450.  
  451.  htd {
  452. ; Try a second order inductive term.
  453.       z = zp2 = pixel, zp1 = (0,0), huge=1.0e32:
  454.       temp = z
  455.       z = zp1*zp1 - zp2
  456.       zp2 = zp1
  457.       zp1 = p1/temp, (|zp1| <= 64) && (|z| <= huge) }
  458.  
  459.  htgen {
  460. ; Try a second order inductive term.
  461.       z = pixel, zp1 = (0,0), bail=real(p2),huge=1.0e32:
  462.       temp = z
  463.       z = z*z + zp1
  464.       zp1 = p1/temp, (|zp1| <= bail) && (|z| <= huge) }
  465.  
  466.  
  467.  yyt {
  468. ; Changing the yyy to the more general form using P1
  469.       z = zp1 = pixel, zp2 = (0,0), huge=1.0e32:
  470.       temp = z
  471.       z = zp1^z - zp2
  472.       zp2 = zp1
  473.       zp1 = p1/temp, (|zp2| <= 64) && (|z| <= huge) }
  474.  
  475.  newt {
  476. ; Playing around with variations of the ht type. This is a frog mutation.
  477. ; Try values of P1 between 0.2 and 1.0 Also try the imaginary component.
  478.         z=pixel, zp = (0,0), huge=1.0e32:
  479.           temp = z
  480.           z = z*-z + zp
  481.           zp = p1/temp^.5, (|zp| <= 4) && (|z| <= huge) }
  482.  
  483.  rat {
  484. ; Still more attempts at ht variants
  485.       z = zp1 = pixel, zp2 = (0,0),huge=1.0e32:
  486.       temp = z
  487.       z = z*z - zp2
  488.       zp2 = zp1
  489.       zp1 = (temp/zp1)*p1, (|zp1| <= 64) && (|z| <= huge) }
  490.  
  491.  octet {
  492. ; The ht varient of the octo formula
  493.       z = pixel,zp=(0,0),huge=1.0e32:
  494.       temp = z
  495.       z = z^3 + zp
  496.       zp = p1/temp, (|zp| <=64) && (|z| <= huge) }
  497.  
  498.  tsept {
  499. ; Why not try this change on all the good formula so far?
  500.       z = pixel, zp1 = zp2 = (0,0), huge = 1.0e32:
  501.       temp = z
  502.       z = z*z - zp2
  503.       zp2 = zp1
  504.       zp1 = p1/temp, (|zp1| <= 64) && (|z| <= huge) }
  505.  
  506.  htree(XAXIS)  {
  507. ; Try a different order of the terms.
  508.       z = zp2 = pixel,  zp1 = (0,0), huge = 1.0e32:
  509.       temp = z
  510.       z = zp1*zp1  - zp2
  511.       zp2 = zp1
  512.       zp1 = p1/temp, (|zp1| <= 64) && (|z| <= huge) }
  513.  
  514. ; This next formula seems to be closely related to one of the lambda[sin]
  515. ; functions in " The Science of fractal Images" page 162.
  516. ; by H.O. Peitgen and D. Saupe
  517. ; Related yes, although it's not obvious to me why at this time. Curious?
  518. ; Oh, yes! You will have to zoom out to +/- 2 pi on the x axis
  519.  
  520.  quartet {
  521. ; The quatro-HT variation. Use real part of p1  0.0 < p1 < 1.0
  522. ; Adding the inversion causes what looks like an infinite extension along
  523. ; the real axis. Using the Imag component will add some nice asymmetry.
  524.        z=pixel, zp = (0,0), huge = 1.0e32:
  525.        temp = z
  526.        z = sin(z) - zp
  527.        zp = p1/temp, (|zp| <= 4 && |z| <= huge) }
  528.  
  529.  quartet1 {
  530. ; increasing the bailout will reduce the disk size and a wider and
  531. ; more interesting range of workable P1 input parameters.
  532.        z=pixel, zp = (0,0), huge = 1.0e32:
  533.        temp = z
  534.        z = sin(z) - zp
  535.        zp = p1/temp, (|zp| <= huge && |z| <= huge) }
  536.  
  537.  
  538.  quartz {
  539.       z=c=pixel, zp = (0,0), huge = 1.0e32:
  540.        temp = z
  541.        z = -sin(z) - zp
  542.        zp = p1/temp, (|zp| <= huge && |z| <= huge) }
  543.  
  544.  janet {
  545.        z=zp1=pixel, zp2 = (0,0), huge = 1.0e32:
  546.        temp = z
  547.        z = sin(z) - zp2
  548.        zp2 = zp1
  549.        zp1 = p1/temp, (|zp2| <= 4 && |z| <= huge) }
  550.  
  551.  quartc {
  552. ; This makes for an unusual combination of fractal characteristics
  553. ; Recognizable sin fractal filled with chaotic banding.
  554. ; Real part of P1 should be about 0.1 and Imag portion can be 0.0
  555. ; Oh yes! You will have to zoom out to +/- 2pi on the x axis for full view.
  556.        z=pixel, zp = (0,0), huge = 1.0e32:
  557.        temp = z
  558.        z = sin(z) - zp
  559.        zp = p1/conj(temp),(|zp| <= 4 && |z| <= huge) }
  560.  
  561.  pheot {
  562. ; The ht flavour of the pheonix fractal gives some nice escher like
  563. ; fractals
  564.       z = pixel, zp1 = zp2 = (0,0),huge=1.0e32:
  565.       temp = z
  566.       z  = z*z - zp2
  567.       zp2 = zp1
  568.       zp1 = p1/conj(temp), (|zp1| <= 64) && (|z| <= huge) }
  569.  
  570.  pheot1 {
  571. ; The ht flavour of the pheonix fractal gives some nice escher like
  572. ; fractals
  573.       z = pixel, zp1 = zp2 = (0,0), bail=real(p2), huge=1.0e32:
  574.       temp = z
  575.       z  = z*z - zp2
  576.       zp2 = zp1
  577.       zp1 = p1/conj(temp), (|zp1| <= bail) && (|z| <= huge) }
  578.  
  579.  
  580.  pentet {
  581. ; the HT variant of the penta formula
  582.         z = pixel, zp = (0,0),huge=1.0e32:
  583.           temp = z
  584.           z = z*z - zp
  585.           zp = p1/conj(temp), (|zp| <= 64) && (|z| <= huge) }
  586.  
  587.  tstar {
  588. ; For the star fractal as well it makes a dramatic change.
  589. ; Use real 0.1 < p1 < 1.0
  590.         z=pixel, zp = (0,0),huge=1.0e32:
  591.           temp = z
  592.           z = z*z + zp
  593.           zp = p1/conj(temp), (|zp| <= 64) && (|z| <= huge) }
  594.  
  595.  petcock (XAXIS) {
  596.       z = pixel, zp = (0,0):
  597.       temp = z
  598.       z = -cos(z) - zp
  599.       zp = 1/temp, |zp| <=64 }
  600.  
  601.  tpet {
  602.       z = pixel, zp = (0,0), huge=1.0e32:
  603.       temp = z
  604.       z = -cos(z) - zp
  605.       zp = p1/temp, (|zp| <= 64) && (|z| <= huge) }
  606.  
  607.  tpet1 {
  608.       z = pixel, zp = (0,0), huge=1.0e32:
  609.       temp = z
  610.       z = cos(z) - zp
  611.       zp = p1/temp, (|zp| <= 64) && (|z| <= huge) }
  612.  
  613.  tpet2 {
  614.       z = pixel, zp = (0,0), huge=1.0e32:
  615.       temp = z
  616.       z = cos(z) + zp
  617.       zp = p1/temp, (|zp| <= 4) && (|z| <= huge) }
  618.  
  619.  htexp1 {
  620. ; An exponential function can produce fractals as well
  621.       z = pixel, bail=real(p2), zp = (0,0), huge=1.e32:
  622.       temp = z
  623.       z = -exp(z) - zp
  624.       zp = p1/temp, (|zp| <=bail && |z| <=huge)}
  625.  
  626.  htexp2 {
  627. ; An exponential function can produce fractals as well
  628.       z = pixel, bail=real(p2), zp = (0,0), huge=1.e32:
  629.       temp = z
  630.       z = exp(z) - zp
  631.       zp = p1/temp, (|zp| <=bail && |z| <=huge)}
  632.  
  633.  htexp3 {
  634. ; An exponential function can produce fractals as well
  635.       z = pixel, bail=real(p2), zp = (0,0), huge=1.e32:
  636.       temp = z
  637.       z = exp(z) + zp
  638.       zp = p1/temp, (|zp| <=bail && |z| <=huge)}
  639.  
  640.  
  641. ;========================================================================
  642. ; The  following aren't really fractals, but are some rather strange
  643. ; anomolies that I've stumbled across and kept to play with.
  644.  
  645.    quilt(XAXIS) {
  646. ; The combination of a typing error and a bug in fractints parser
  647. ; makes weird quilt like patterns, I hope they don't fix it. I like it.
  648.      z = = zp1 = pixel, zp2 = (0,0):
  649.       temp = z
  650.       z = zp2*zp2  - zp1
  651.       zp2 = zp1
  652.       zp1 = temp^.5, |zp1| <= 4}
  653.  
  654.    textur1(XAXIS) {
  655. ; Zoom into the noise region outside the 2.0 radius with 256 colour decomp
  656. ; or try boundary tracing in iter=summ or mult mode. Make sure float=yes
  657. ; earlier versions of fractint had more trouble with this equation
  658. ; and broke inside as well.
  659.       z = zp1 = pixel, zp2 = (0,0):
  660.       temp = z
  661.       z = zp1*zp1 - zp2
  662.       zp2 = zp1
  663.       zp1 = temp^0.5, |zp1| <= 4}
  664.  
  665.    textur2(XAXIS) {
  666. ; A minor variation on the previous formula to see what happens
  667. ; Zoom in far enough and find some strange moire' patterns.
  668.       z = zp1 = zp2 = pixel:
  669.       temp = z
  670.       z = zp1*zp1 - zp2
  671.       zp2 = zp1
  672.       zp1 = temp^0.5, |zp1| <= 4}
  673. ;========================================================================
  674. ;                     Noel@reg.triumf.ca
  675.