Welcome to Fractal Forums

var x int;
var y int;
var color int;

extern breakbound real = 1e9;
extern maxdepth int = 100;
var lyaexp realf = 0;
var i = 0;

func step(r) {
   z = r * z * (1 - z);
   lyaexp = lyaexp + log abs r (1 - 2z);
   next(i, maxdepth) and abs lyaexp < breakbound // returns a boolean
}

func fullstep(a, b) {
   step b and step b and step b and step b and step b and step b 
   and step a and step a and step a and step a and step a and step a
}

var z real = 0.5;

extern pospal palette = [[#000, #a40, #fca, #fff]];
extern negpal palette = [[#000, #ccf, #88f]];

union c cplx;
var a real; var b real; 

c = map(x, y);
var i = 0;
while fullstep(a, b);

lyaexp = lyaexp / i;

color = lab2int (if lyaexp < 0 
 then negpal (4 log (1 + log (1 - lyaexp)))
 else pospal (6 lyaexp))

scale 0.04366290828827071:0.035604162859637425 -0.035604162859637425:0.04366290828827071 0.16822888372571776:-0.254779458308629
program "

var x int;
var y int;
var color int; 

extern alpha cplx = 1:0;
extern beta cplx = 2:0;
extern gamma cplx = 1:0;
extern delta cplx = -2:0;

// faster to put them into variables.
//  by default would be cplx.
var aa cplxf = alpha;
var bb cplxf = beta;
var cc cplxf = gamma;
var dd cplxf = delta;

func init(c) {
  (-cc * dd / (aa * bb))^(1/(bb - dd))
}

func fun(z, zz, c) {
 // interesting variation is to insert abs/conj
 // before power (==> burning-ship-alikes)
 c * (aa * z^bb + cc * z^dd)
}

extern maxdepth int = 120;
extern bailout real = 64;
extern epsilon real = 1e-9;
extern bailoutpalette palette = [[#000, #0a0, #acf, #804, #fe8]];
extern lakepalette palette = [[#a00, #ff4, #fff, #004]];

// power is only for cplxf
var c cplxf = map(x, y); 
var z cplxf = init c;
var zz cplxf = 0;

var i = 0;
var power = max(re bb, re dd);

func smoothlen() {
 lab2int bailoutpalette log(i + smooth(z, bailout, power))
}

func lastarc() {
 lab2int lakepalette arcnorm z
}

while {
 var t = z;
 z = fun(z, zz, c);
 zz = t;

 not radrange(z, zz, bailout, epsilon,
         color = smoothlen(), color = lastarc())
     and (
             next(i, maxdepth)
         or
             { color = lastarc() ; false })
};"
ints {
}
reals {
bailout 1000000.0
}
cplxs {
delta -2.0:1.0
}
colors {
}
palettes {
bailoutpalette [[#000000, #e8ecff, #880044, #ffee88]]
lakepalette [[#ffffff, #000044]]
}

// 'Ducks' fractal by Samuel Monnier
// (Implementation by Syntopia)
// See http://www.algorithmic-worlds.net/blog/blog.php?Post=20110227
vec2 formula(vec2 z, vec2 c) {
    return cLog(vec2(z.x,abs(z.y)))+c;
}

func init(c) { 0 }

func labs(a) {
   if im(a) > 0 then a else conj a
}

func fun(z, zz, c) {
  log(labs z + c);
}

var x int;
var y int;
var color int;

extern maxdepth int = 120;
extern bailout real = 64;
extern epsilon real = 1e-9;
extern lakepalette palette = [[#000, #0a0, #fb8, #fff]];

var c cplxf = map(x, y);
var z cplxf = init c;
var zz cplxf;

var i = 0;

func lastarc() {
    lab2int lakepalette (4 * arcnorm z)
}

while {
   var t = z;
   z = fun(z, zz, c);
   zz = t;
   not diffless(z, zz, epsilon)
      and next(i, maxdepth)
   or { color = lastarc() ; false }
};

func init(c) { 0 }

func bar(a) {
   if re(a) > 0 then a-1 else a+1;
}

func fun(z, zz, c) {
  bar(z) * c;
}

var x int;
var y int;
var color int;

extern maxdepth int = 120;
extern bailout real = 64;
extern epsilon real = 1e-9;
extern lakepalette palette = [[#000, #0a0, #fb8, #fff]];

var c cplxf = map(x, y);
var z cplxf = init c;
var zz cplxf;

var i = 0;

func lastarc() {
    lab2int lakepalette (4 * arcnorm z)
}

while {
   var t = z;
   z = fun(z, zz, c);
   zz = t;
   not diffless(z, zz, epsilon)
      and next(i, maxdepth)
   or { color = lastarc() ; false }
};

func init(c) { 1 }

func fun(z, zz, c) {
  z - (z*z*z-1)/(3*z*z) + c
}

var x int;
var y int;
var color int;

extern maxdepth int = 120;
extern bailout real = 64;
extern epsilon real = 1e-9;
extern lakepalette palette = [[#000, #0a0, #fb8, #fff]];

var c cplxf = map(x, y);
var z cplxf = init c;
var zz cplxf;

var i = 0;

func lastarc() {
    lab2int lakepalette (4 * arcnorm z)
}

while {
   var t = z;
   z = fun(z, zz, c);
   zz = t;
   not diffless(z, zz, epsilon)
      and next(i, maxdepth)
   or { color = lastarc() ; false }
};

func init(c) { 1 }
extern zpow real = 3;


func fun(z, zz, c) {
  z - (z^(zpow)-1)/(zpow*(z^(zpow-1))) + c
}

func fun(z, zz, c) {
    var tmp = z - (z^(zpow)-1)/(zpow*(z^(zpow-1))) + c ;
    tmp
}