This digital works is created exclusively from fractals, with 0% AI generated. It can therefore be converted into a set of functions and parameters that can be the basis for the training of an AI.

The mathematical formulas and parameter combinations corresponding to each fractal are presented below. In each case, the numerical characters have been replaced by ■ to prevent unauthorized reproduction. If you are interested in using the full data set to train an AI, please contact Philippe.

Fractal_■■■_B {
fractal:
title="Fractal_■■■_B" width=■■■■ height=■■■■ layers=■
credits="Philoxerax;■■/■■/■■■■"
layer:
caption="bloc blanc haut" opacity=■■■ visible=no transparent=yes
mapping:
center=-■.■■■■■■■■/-■■.■■■■■■■■■ magn=■.■■■■■■■■■
formula:
maxiter=■■■■ filename="reb.ufm" entry="SlopeExpFun_BarnsleyM■"
p_version=■.■ p_bailout=■■■■■.■ p_zmode="smoothed iteration"
p_offset=■.■■■■■■■■ p_xfer=linear p_zscale=■.■ p_zscale■=■.■■■
p_everyiter=no f_fn■=round f_fn■=ident
inside:
transfer=none solid=■■■■■■■■■■
outside:
transfer=linear
gradient:
smooth=yes index=■■ color=■■■■■■■■
opacity:
smooth=no rotation=-■■ index=■■ opacity=■ index=-■■■ opacity=■■■
index=-■■ opacity=■
layer:
caption="bloc jaune haut" opacity=■■■ transparent=yes
mapping:
center=-■.■■■■■■■■/-■■.■■■■■■■■ magn=■.■■■■■■■■■
formula:
maxiter=■■■■ filename="reb.ufm" entry="SlopeExpFun_BarnsleyM■"
p_version=■.■ p_bailout=■■■■■.■ p_zmode="smoothed iteration"
p_offset=■.■■■■■■■■ p_xfer=linear p_zscale=■.■ p_zscale■=■.■■■
p_everyiter=no f_fn■=round f_fn■=ident
inside:
transfer=none solid=■■■■■■■■■■
outside:
transfer=linear
gradient:
smooth=yes index=■■ color=■■■■■■■■
opacity:
smooth=no rotation=-■■ index=■■ opacity=■ index=-■■■ opacity=■■■
index=-■■ opacity=■
layer:
caption="bloc blanc bas" opacity=■■■ mergemode=hardlight
transparent=yes
mapping:
center=-■.■■■■■■■■/-■■.■■■■■■■ magn=■.■■■■■■■■■
formula:
maxiter=■■■■ filename="reb.ufm" entry="SlopeExpFun_BarnsleyM■"
p_version=■.■ p_bailout=■■■■■.■ p_zmode="smoothed iteration"
p_offset=■.■■■■■■■■ p_xfer=linear p_zscale=■.■ p_zscale■=■.■■■
p_everyiter=no f_fn■=round f_fn■=ident
inside:
transfer=none solid=■■■■■■■■■■
outside:
transfer=linear
gradient:
smooth=yes index=■■ color=■■■■■■■■
opacity:
smooth=no rotation=-■■ index=■■ opacity=■ index=-■■■ opacity=■■■
index=-■■ opacity=■
layer:
caption="bloc jaune bas" opacity=■■■ mergemode=hardlight
transparent=yes
mapping:
center=-■.■■■■■■■■/-■■.■■■■■■■■■ magn=■.■■■■■■■■■
formula:
maxiter=■■■■ filename="reb.ufm" entry="SlopeExpFun_BarnsleyM■"
p_version=■.■ p_bailout=■■■■■.■ p_zmode="smoothed iteration"
p_offset=■.■■■■■■■■ p_xfer=linear p_zscale=■.■ p_zscale■=■.■■■
p_everyiter=no f_fn■=round f_fn■=ident
inside:
transfer=none solid=■■■■■■■■■■
outside:
transfer=linear
gradient:
smooth=yes index=■■ color=■■■■■■■■
opacity:
smooth=no rotation=-■■ index=■■ opacity=■ index=-■■■ opacity=■■■
index=-■■ opacity=■
layer:
caption="Background" opacity=■■■ method=multipass
mapping:
center=■.■■■■■■■■■/-■.■■■■■■■■■ magn=■.■■■■■■■ angle=■■
formula:
maxiter=■■■■ percheck=off filename="reb.ufm" entry="JuliaTentMap"
p_version=■ p_p■=■.■■■/■.■■ p_type=cabs p_flavor="Flavor ■"
p_invert=no p_test=and p_bailout=■■■ p_tent■=■ p_tent■=■ p_tent■=■.■
f_tentfn=atan f_tentfn■=sqr
inside:
transfer=none
outside:
transfer=linear
gradient:
smooth=yes rotation=■■ index=■■ color=■■■■■■■ index=■■■
color=■■■■■■■■ index=■■■ color=■■■■■■■ index=■■■ color=■■■■■■■■
index=■■■ color=■■■■■ index=■■■ color=■■■■■■■ index=■■■
color=■■■■■■■ index=■■■ color=■■■■■■■
opacity:
smooth=no index=■ opacity=■■■
}

SlopeExpFun_BarnsleyM■ { ; Ron Barnett, April ■■■■
;
init:
complex c■ = #pixel; primary iterated point
complex c■ = #pixel + @offset; horizontally offset point
complex c■ = #pixel + flip(@offset); vertically offset point
complex z■ = ■
complex z■ = ■
complex z■ = ■
int done = ■
float modz = ■.■
float e■ = ■.■; potentials
float e■ = ■.■
float e■ = ■.■
float vx = ■.■; normal vector
float vy = ■.■
float vz = ■.■
float vd = ■.■
float d■ = ■.■ ; distances
float d■ = ■.■
float d■ = ■.■
float s■ = ■.■e■■ ; smallest distances
float s■ = ■.■e■■
float s■ = ■.■e■■
float iterexp■ = ■.■
float iterexp■ = ■.■
float iterexp■ = ■.■
loop:
IF real(z■) >= ■
z■ = @fn■(z■)
z■ = (z■ - ■) * c■
ELSE
z■ = @fn■(z■)
z■ = (z■ + ■) * c■
ENDIF
IF real(z■) >= ■
z■ = @fn■(z■)
z■ = (z■ - ■) * c■
ELSE
z■ = @fn■(z■)
z■ = (z■ + ■) * c■
ENDIF
IF real(z■) >= ■
z■ = @fn■(z■)
z■ = (z■ - ■) * c■
ELSE
z■ = @fn■(z■)
z■ = (z■ + ■) * c■
ENDIF
iterexp■ = iterexp■ + exp(-cabs(z■))
iterexp■ = iterexp■ + exp(-cabs(z■))
iterexp■ = iterexp■ + exp(-cabs(z■))
done = done + ■; increment iteration counter
z■ = fn■(z■)
z■ = fn■(z■)
z■ = fn■(z■)
IF (@zmode == ■) ; smallest |z|
d■ = |z■| ; get current distances from origin
d■ = |z■|
d■ = |z■|
IF (d■ < s■) ; update smallest distances
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
ELSEIF (@zmode == ■) ; smallest |real(z)|
d■ = abs(real(z■)) ; get current distances from i axis
d■ = abs(real(z■))
d■ = abs(real(z■))
IF (d■ < s■) ; update smallest distances
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
ELSEIF (@zmode == ■) ; smallest |imag(z)|
d■ = abs(imag(z■)) ; get current distances from r axis
d■ = abs(imag(z■))
d■ = abs(imag(z■))
IF (d■ < s■) ; update smallest distances
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
ELSEIF (@zmode == ■) ; smallest |real(z)|+|imag(z)|
d■ = abs(real(z■))+abs(imag(z■)) ; get current distances from i axis
d■ = abs(real(z■))+abs(imag(z■))
d■ = abs(real(z■))+abs(imag(z■))
IF (d■ < s■) ; update smallest distances
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
ELSEIF (@zmode == ■) ; smallest |atan(z)|
d■ = abs(atan■(z■)) ; get current angles
d■ = abs(atan■(z■))
d■ = abs(atan■(z■))
IF (d■ < s■) ; update smallest distances
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
IF (d■ < s■)
s■ = d■
ENDIF
ENDIF
modz = |z■|
IF (modz > @bailout ||\
@everyiter ||\
done == #maxit + ■); done, or every iteration, or last
; determine continuous iteration (height) for each point
IF (@zmode >= ■ && @zmode <= ■) ; height based on smallest |z|
e■ = s■ * @zscale
e■ = s■ * @zscale
e■ = s■ * @zscale
ELSEIF (@zmode == ■)
e■ = iterexp■ * @zscale
e■ = iterexp■ * @zscale
e■ = iterexp■ * @zscale
ENDIF
; apply transfer function
; a function is not used because these are floats
; and not all functions apply to floats
IF (@xfer == ■); log
e■ = log(e■)
e■ = log(e■)
e■ = log(e■)
ELSEIF (@xfer == ■); sqrt
e■ = sqrt(e■)
e■ = sqrt(e■)
e■ = sqrt(e■)
ELSEIF (@xfer == ■); cuberoot
e■ = (e■)^(■/■)
e■ = (e■)^(■/■)
e■ = (e■)^(■/■)
ELSEIF (@xfer == ■); exp
e■ = exp(e■)
e■ = exp(e■)
e■ = exp(e■)
ELSEIF (@xfer == ■); sqr
e■ = sqr(e■)
e■ = sqr(e■)
e■ = sqr(e■)
ELSEIF (@xfer == ■); cube
e■ = (e■)^■
e■ = (e■)^■
e■ = (e■)^■
ELSEIF (@xfer == ■); sin
e■ = sin(e■)
e■ = sin(e■)
e■ = sin(e■)
ELSEIF (@xfer == ■); cos
e■ = cos(e■)
e■ = cos(e■)
e■ = cos(e■)
ELSEIF (@xfer == ■); tan
e■ = tan(e■)
e■ = tan(e■)
e■ = tan(e■)
ENDIF
; apply post-scale
e■ = e■ * @zscale■
e■ = e■ * @zscale■
e■ = e■ * @zscale■
vx = e■-e■
vy = e■-e■
vz = -@offset
; normalize vector
vd = ■/sqrt(sqr(vx)+sqr(vy)+sqr(vz))
vx = vx*vd
vy = vy*vd
vz = vz*vd
z = vx + flip(vy); fudge z from vector
ELSE; didn't compute z this time
z = z■; use primary iteration value to keep periodicity working
ENDIF
IF (modz > @bailout); we're done
done = ■
ENDIF
bailout:
(done > ■)
default:
title = "SlopeExp (Fun_BarnsleyM■)"
maxiter = ■■■■
param version
caption = "Formula Version"
default = ■.■
hint = "You should never see this parameter; it's used internally to track \
which version of the formula was used to create your image, so that \
if a bug is found which breaks backwards-compatibility, the formula \
can adapt transparently."
visible = false
endparam
param version
caption = "Formula Version"
default = ■.■
hint = "You should never see this parameter; it's used internally to track \
which version of the formula was used to create your image, so that \
if a bug is found which breaks backwards-compatibility, the formula \
can adapt transparently."
visible = false
endparam
param bailout
caption = "Bailout Value"
default = ■■■■■.■
min = ■.■
hint = "Defines how soon an orbit bails out, i.e. doesn't belong \
to the Mandelbrot set anymore."
endparam
param zmode
caption = "Height Value"
default = ■
enum = "smallest |z|" "smallest |real(z)|" \
"smallest |imag(z)|" "smallest summ(z)" "smallest |atan(z)|" \
"smoothed iteration"
hint = "Specifies what will be used to construct a height value."
endparam
param offset
caption = "Orbit Separation"
default = ■.■■■■■■■■
hint = "Defines how far apart the simultaneous orbits are. Smaller \
distances will produce more accurate results."
endparam
param xfer
caption = "Height Transfer"
default = ■
enum = "linear" "log" "sqrt" "cuberoot" "exp" "sqr" "cube" "sin" "cos" "tan"
hint = "This function will be applied to the height value \
before a slope is calculated."
endparam
param zscale
caption = "Height Pre-Scale"
default = ■.■
hint = "Specifies the ratio between height and distance. Higher \
values will exaggerate differences between high and low. \
In general, you will want to use smaller numbers here."
endparam
param zscale■
caption = "Height Post-Scale"
default = ■.■■■
hint = "Specifies the ratio between height and distance; like \
Height Pre-Scale, except that this value is applied after \
the transfer function."
endparam
param everyiter
caption = "Every Iteration"
default = false
hint = "If set, the surface normal will be computed at every \
iteration. If you are using a coloring algorithm which \
processes every iteration, you will need this."
endparam
func fn■
caption = "Input Function"
default = ident()
endfunc
func fn■
caption = "Scaling Function"
default = ident()
endfunc
switch:
type = "SlopeExpFun_BarnsleyJ■"
seed = #pixel
bailout = @bailout
zmode = @zmode
offset = @offset
xfer = @xfer
zscale = @zscale
zscale■ = @zscale■
everyiter = @everyiter
fn■ = @fn■
fn■ = @fn■
}
JuliaTentMap {; Ron Barnett, August ■■■■
; based upon the tent map formula and the Barnsley
; fractal algorithm
init:
if @invert
#z = ■/(#pixel+(■.■■■■■■,■.■■■■■■))
else
#z = #pixel
endif
if @flavor == "Flavor ■"
#z = @tentfn(#z)
endif
loop:
if @flavor == "Flavor ■"
#z = @tentfn(#z)
endif
if @invert
if @type == "cabs"
if cabs(@tentfn■(#z)) <= @tent■
#z = @tent■*#z/(@p■+(■.■■■■■■,■.■■■■■■))
else
#z = @tent■*(@tent■-#z)/(@p■+(■.■■■■■■,■.■■■■■■))
endif
elseif @type == "real"
if real(@tentfn■(#z)) <= @tent■
#z = @tent■*#z/(@p■+(■.■■■■■■,■.■■■■■■))
else
#z = @tent■*(@tent■-#z)/(@p■+(■.■■■■■■,■.■■■■■■))
endif
elseif @type == "imag"
if imag(@tentfn■(#z)) <= @tent■
#z = @tent■*#z/(@p■+(■.■■■■■■,■.■■■■■■))
else
#z = @tent■*(@tent■-#z)/(@p■+(■.■■■■■■,■.■■■■■■))
endif
else
if imag(@tentfn■(#z)) > @tent■
#z = @tent■*(@p■-#z)/(#pixel+(■.■■■■■■,■.■■■■■■))
elseif real(@tentfn■(#z)) > @tent■
#z = @tent■*(@p■-#z)/(#pixel+(■.■■■■■■,■.■■■■■■))
else
#z = @tent■*#z/(@p■+(■.■■■■■■,■.■■■■■■))
endif
endif
else
if @type == "cabs"
if cabs(@tentfn■(#z)) <= @tent■
#z = @tent■*#z*@p■
else
#z = @tent■*(@tent■-#z)*@p■
endif
elseif @type == "real"
if real(@tentfn■(#z)) <= @tent■
#z = @tent■*#z*@p■
else
#z = @tent■*(@tent■-#z)*@p■
endif
elseif @type == "imag"
if imag(@tentfn■(#z)) <= @tent■
#z = @tent■*#z*@p■
else
#z = @tent■*(@tent■-#z)*@p■
endif
else
if imag(@tentfn■(#z)) > @tent■
#z = @tent■*(@tent■-#z)*@p■
elseif real(@tentfn■(#z)) > @tent■
#z = @tent■*(@tent■-#z)*@p■
else
#z = @tent■*#z*@p■
endif
endif
endif
bailout:
(@test == ■ && |#z| <= @bailout) || \
(@test == ■ && sqr(real(#z)) <= @bailout) || \
(@test == ■ && sqr(imag(#z)) <= @bailout) || \
(@test == ■ && (sqr(real(#z)) <= @bailout && sqr(imag(#z)) < @bailout)) || \
(@test == ■ && (sqr(real(#z)) <= @bailout || sqr(imag(#z)) < @bailout)) || \
(@test == ■ && (sqr(abs(real(#z)) + abs(imag(#z))) <= @bailout)) || \
(@test == ■ && (sqr(real(#z) + imag(#z)) <= @bailout))
default:
title = "Julia TentMap"
maxiter = ■■■■
center = (■, ■)
periodicity = ■
method = multipass
heading
caption = "Julia TentMap"
endheading
$ifdef VER■■
heading
text = "Based upon the Tent Map:"
endheading
heading
text = " T(x) = s*x for x <= ■.■"
endheading
heading
text = " T(x) = s*(■-x) for x > ■.■"
endheading
heading
text = "and the code for the Barnsley type fractals."
endheading
$else
heading
caption = "Based upon the Tent Map:"
endheading
heading
caption = " T(x) = s*x for x <= ■.■"
endheading
heading
caption = " T(x) = s*(■-x) for x > ■.■"
endheading
$endif
float param version
caption = "Version number"
default = ■.■
hint = "This is for backwards compatibility with old versions \
of the formula."
visible = false
endparam
param p■
caption = "Julia seed"
default = (■.■, ■)
endparam
param type
caption = "Tent type"
default = ■
enum = "cabs" "real" "imag" "Pinsky"
endparam
param flavor
caption = "Flavor"
default = ■
enum = "Flavor ■" "Flavor ■"
endparam
bool param invert
caption = "Inversion"
default = false
endparam
param test
caption = "Bailout Test"
default = ■
enum = "mod" "real" "imag" "or" "and" "manh" "manr"
endparam
float param bailout
caption = "Bailout value"
default = ■■■■■
min = ■
endparam
float param tent■
caption ="Tent param #■"
default = ■
endparam
float param tent■
caption ="Tent param #■"
default = ■
endparam
float param tent■
caption ="Tent param #■"
default = ■.■
endparam
func tentfn
caption = "Tent function"
default = abs()
endfunc
func tentfn■
caption = "Tent function #■"
default = ident()
endfunc
switch:
type = "TentMap"
bailout = @bailout
test = @test
tent■ = @tent■
tent■ = @tent■
tent■ = @tent■
type = @type
tentfn = @tentfn
tentfn■ = @tentfn■
flavor = @flavor
invert = @invert
}