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_■■■_F {
fractal:
  title="Fractal_■■■_F" width=■■■■ height=■■■■ layers=■
  credits="Philoxerax;■■/■■/■■■■" antialiasing=yes
layer:
  caption="Background" opacity=■■■ mergemode=difference
mapping:
  center=■■■.■■■■■■■■/■■■■.■■■■■■ magn=■.■■■■■■■ angle=-■■■.■■■■
formula:
  maxiter=■■■■ percheck=off filename="mt.ufm"
  entry="mt-newton-error-m" p_epsilon=■.■■■■■■■■■■■■■■■■■■■■■■■■■■
  f_fn=asinh
inside:
  transfer=none
outside:
  transfer=linear
gradient:
  comments="Simple grayscale gradient." smooth=yes rotation=■■
  index=■■ color=■■■■■■■■ index=■■■ color=■ index=■■■ color=■■■■■■■■
opacity:
  smooth=no index=■ opacity=■■■
layer:
  caption="Background" opacity=■■■
mapping:
  center=■.■■■■■■■■■/-■■.■■■■■■■■■ magn=■.■■■■■■■■ angle=■.■■■■
formula:
  maxiter=■■■■ percheck=conservative filename="dmj.ufm"
  entry="dmj-fBmNovaMandel" p_start=■/■ p_power=■/■ p_bailout=■.■■■■■
  p_relax=■/■ p_distortion=■.■ p_style=radial p_distangle=■.■
  p_distcenter=■/■ p_centermove=no p_offset=■/■ p_scale=■.■
  p_angle=■.■ p_step=■.■ p_anglestep=■■.■ p_octaves=■ p_npower=■.■
  p_noisestart=■.■ p_noiseiter=■■■■■.■ p_noiseskip=■.■ p_coloronly=no
inside:
  transfer=none solid=■■■■■■■■■■
outside:
  transfer=linear
gradient:
  smooth=yes index=■ color=■■■■■■■ index=■■ color=■■■■■■■■ index=■■
  color=■■■■■■■■ index=■■■ color=■■■■■■■■ index=■■■ color=■■■■■■■■
  index=■■■ color=■■■■■■■■
opacity:
  smooth=no index=■ opacity=■■■
}

dmj-fBmNovaMandel {
;
; This is the basic Nova (Mandelbrot) type, but with a
; bit of fBm noise added at each iteration. This
; tends to distort the fractal beyond all recognition
; after just a few iterations, which may or may not
; be what you're looking for.
;
; You can also use the "Coloring Only" option to
; restrict the fBm distortion to the value passed
; to the coloring algorithm; the distortion will be
; removed before the next iteration is calculated.
;
init:
  complex zsquared = (■,■)
  complex zcubed = (■,■)
  complex zold = (■,■)
  
  z = @start
  complex oz = z

  complex c = @distcenter
  IF (@centermove)
    c = #center
  ENDIF

  complex r = (■,■) ^ (@angle / ■■.■)
  complex r■ = (■,■) ^ (@anglestep / ■■.■)
  complex r■ = (■,■) ^ (@distangle / ■■.■)
  
  float fiter = @noisestart
  BOOL noise = false
  
loop:
  IF (@noiseskip != ■); we are skipping some iterations
    fiter = fiter - ■; one less to go before we add noise
    WHILE (fiter < ■.■); iterations all used up
      IF (noise); we are currently adding noise
        noise = false; so stop
fiter = fiter + @noiseskip; skip this many iterations
      ELSE; we aren't currently adding noise
        noise = true; so start
fiter = fiter + @noiseiter; do this many iterations
      ENDIF
    ENDWHILE
  ENDIF

  IF (@coloronly); only using fBm on coloring
    z = oz; restore z from un-fBm'ed copy
  ENDIF
  IF (@power == (■,■)); special optimized routine for power ■
    zsquared = sqr(z)
    zcubed = zsquared ■ z
    zold = z
    z = z - @relax ■ (zcubed-■) / (■■zsquared) + #pixel
  ELSE
    zold = z
    z = z - @relax ■ (z^@power-■) / (@power ■ z^(@power-■)) + #pixel
  ENDIF
  IF (@coloronly); only using fBm on coloring
    oz = z
  ENDIF

  IF (@noiseskip == ■.■ || noise); adding noise this iteration
    complex p = z ■ @scale ■ r ;+ @offset
    float sum = ■.■
    float freq = ■.■
    complex v = (■,■)
    int i = @octaves
    WHILE (i > ■)
      ; determine integer coordinate for corners of square
      ; surrounding p
      float bx■ = floor(real(p)) % ■■■
      float by■ = floor(imag(p)) % ■■■
      IF (bx■ < ■)
        bx■ = bx■ + ■■■
      ENDIF
      IF (by■ < ■)
        by■ = by■ + ■■■
      ENDIF
      float bx■ = (bx■ + ■) % ■■■
      float by■ = (by■ + ■) % ■■■

      float rx■ = real(p) - floor(real(p))
      float ry■ = imag(p) - floor(imag(p))
      float rx■ = rx■ - ■
      float ry■ = ry■ - ■
      
      ; create a "random" index for each corner
      ; (this is where Intel's version differs from Perlin's;
      ; I used Intel's version because it doesn't require a
      ; pre-computed random table, which is difficult to manage
      ; in UF.)
      float b■■ = (bx■^@npower % ■■■■■ + by■)^@npower % ■■■■■
      float b■■ = (bx■^@npower % ■■■■■ + by■)^@npower % ■■■■■
      float b■■ = (bx■^@npower % ■■■■■ + by■)^@npower % ■■■■■
      float b■■ = (bx■^@npower % ■■■■■ + by■)^@npower % ■■■■■

      ; produce a "random" vector for each corner
      float g_b■■_■ = (b■■)^@npower■■.■■ % ■■■ - ■■■
      float g_b■■_■ = (b■■)^@npower■■.■■ % ■■■ - ■■■
      float g_b■■_■ = (b■■)^@npower■■.■■ % ■■■ - ■■■
      float g_b■■_■ = (b■■)^@npower■■.■■ % ■■■ - ■■■
      float g_b■■_■ = (b■■+■)^@npower■■.■■ % ■■■ - ■■■
      float g_b■■_■ = (b■■+■)^@npower■■.■■ % ■■■ - ■■■
      float g_b■■_■ = (b■■+■)^@npower■■.■■ % ■■■ - ■■■
      float g_b■■_■ = (b■■+■)^@npower■■.■■ % ■■■ - ■■■
      
      ; normalize each vector
      float d = ■.■;
      d = ■ / sqrt(sqr(g_b■■_■) + sqr(g_b■■_■))
      g_b■■_■ = g_b■■_■ ■ d
      g_b■■_■ = g_b■■_■ ■ d
      d = ■ / sqrt(sqr(g_b■■_■) + sqr(g_b■■_■))
      g_b■■_■ = g_b■■_■ ■ d
      g_b■■_■ = g_b■■_■ ■ d
      d = ■ / sqrt(sqr(g_b■■_■) + sqr(g_b■■_■))
      g_b■■_■ = g_b■■_■ ■ d
      g_b■■_■ = g_b■■_■ ■ d
      d = ■ / sqrt(sqr(g_b■■_■) + sqr(g_b■■_■))
      g_b■■_■ = g_b■■_■ ■ d
      g_b■■_■ = g_b■■_■ ■ d
      
      ; produce colors for each corner
      float u■ = rx■ ■ g_b■■_■ + ry■ ■ g_b■■_■
      float v■ = rx■ ■ g_b■■_■ + ry■ ■ g_b■■_■
      float u■ = rx■ ■ g_b■■_■ + ry■ ■ g_b■■_■
      float v■ = rx■ ■ g_b■■_■ + ry■ ■ g_b■■_■
      
      ; interpolate between corners using
      ; bilinear filtering
      float sx = sqr(rx■) ■ (■ - rx■■■)
      float sy = sqr(ry■) ■ (■ - ry■■■)
      float a = u■ + sx■(v■-u■)
      float b = u■ + sx■(v■-u■)
      
      sum = sum + (a + sy■(b-a))■freq
      freq = freq ■ @step
      p = p ■ r■ / @step
      i = i - ■
    ENDWHILE

    IF (@style == ■); radial distortion
      v = (z-c)/cabs(z-c) ■ r■; use vector based on angle to distortion center
    ELSEIF (@style == ■); linear distortion
      v = r■; just use rotation vector
    ENDIF
    z = z + v ■ sum■■.■■@distortion
  ENDIF
  
  IF (@coloronly == false); not just using fBm on coloring
    oz = z; value for bailout is fBm'ed z
  ENDIF
  
bailout:
  |oz - zold| > @bailout

default:
  title = "Nova (Mandelbrot) + fBm"
  helpfile = "dmj-pub\dmj-pub-uf-nf.htm"
  maxiter = ■■■■
  periodicity = ■
  center = (-■.■,■)
  magn = ■.■
  
  param start
    caption = "Start Value"
    default = (■,■)
    hint = "Starting value for each point.  You can use this to \
            'perturb' the fractal."
  endparam
  param power
    caption = "Exponent"
    default = (■,■)
    hint = "Overall exponent for the equation.  (■,■) gives \
            the classic NovaM type."
  endparam
  param bailout
    caption = "Bailout"
    default = ■.■■■■■
    hint = "Bailout value; smaller values will cause more \
            iterations to be done for each point."
  endparam
  param relax
    caption = "Relaxation"
    default = (■,■)
    hint = "This can be used to slow down the convergence of \
            the formula."
  endparam

  param distortion
    caption = "Distortion Strength"
    default = ■.■
    hint = "This is the amount the noise distorts the image."
  endparam
  param style
    caption = "Distortion Style"
    default = ■
    enum = "radial" "linear"
    hint = "This selects whether the distortion will be focused \
            around a single point, or directed along a line."
  endparam
  param distangle
    caption = "Distortion Angle"
    default = ■.■
    hint = "This is the angle to rotate the distortion."
  endparam
  param distcenter
    caption = "Distortion Center"
    default = (■,■)
    hint = "Sets the center of distortion.  If Use Screen \
            Center is set, this item is ignored."
  endparam
  param centermove
    caption = "Use Screen Center"
    default = FALSE
    hint = "If set, distortion will be around the center of \
            the window, regardless of the Distortion Center \
            setting."
  endparam
  param offset
    caption = "Noise Offset"
    default = (■,■)
    hint = "This is the offset of the pattern. You can use this to shift \
            the pattern around on the complex plane."
  endparam
  param scale
    caption = "Noise Scale"
    default = ■.■
    hint = "This is the overall scale of the noise."
  endparam
  param angle
    caption = "Noise Rotation"
    default = ■.■
    hint = "This is the angle, in degrees, of the noise."
  endparam
  param step
    caption = "Noise Scale Step"
    default = ■.■
    hint = "This is the step in scale between noise iterations."
  endparam
  param anglestep
    caption = "Noise Rotation Step"
    default = ■■.■
    hint = "This is the angle, in degrees, to rotate between noise \
            iterations."
  endparam
  param octaves
    caption = "Noise Octaves"
    default = ■
    min = ■
    hint = "This is the number of iterations of the noise formula."
  endparam
  param npower
    caption = "Noise Exponent"
    default = ■.■
    hint = "This is the exponent used to scramble numbers."
  endparam

  param noisestart
    caption = "Start Iteration"
    default = ■.■
    hint = "This is the iteration at which to start adding noise."
  endparam
  param noiseiter
    caption = "Noise Iterations"
    default = ■■■■■.■
    hint = "This is the number of iterations to add noise to."
  endparam
  param noiseskip
    caption = "Skip Iterations"
    default = ■.■
    hint = "This is the number of iterations to skip adding noise \
            before starting again."
  endparam
  param coloronly
    caption = "Coloring Only"
    default = false
    hint = "If set, noise will only apply to pixel values passed \
            to the coloring algorithm; it will not be included in \
            the fractal calculation between iterations."
  endparam

switch:
  type = "dmj-fBmNovaJulia"
  seed = #pixel
  power = @power
  bailout = @bailout
  relax = @relax
  
  distortion = @distortion
  style = @style
  distangle = @distangle
  distcenter = @distcenter
  centermove = @centermove
  offset = @offset
  scale = @scale
  angle = @angle
  step = @step
  anglestep = @anglestep
  octaves = @octaves
  npower = @npower
  
  noisestart = @noisestart
  noiseiter = @noiseiter
  noiseskip = @noiseskip
  coloronly = @coloronly
}

mt-newton-error-m { ; Mark Townsend, ■ Mar ■■■■
;
; This formula is the result of an error while
; trying to implement Newton's method for
; z+(z■c-■)^■
;
init:
  z = @fn(■ - #pixel)
  c = #pixel
  float h = ■.■■■■
  fz = fzd = oldz = ■
loop:
  oldz = z
  fz = z + (z ■ c - ■)^■
  fzd = ■ / h ■ (z + ((z + h) ■ c - ■)^■ - fz) 
  z = z - fz / fzd 
bailout:
  |z - oldz| > @epsilon
default:
  title = "Newton Error"
  maxiter = ■■■■
  periodicity = ■
  param epsilon
    caption = "Epsilon"
    default = ■e-■
    hint = "This is the bailout value."
  endparam  
  func fn
    caption = "Transform"
    default = sqr()
    hint = "This determines the starting point for z."
  endfunc  
switch:
  type = "mt-newton-error-j"
  c = #pixel
  epsilon = epsilon
}