Fractal 068 A – Time

Part of OUTER SPACE series – 02 2022

blue . chaos . geometric . path . probability . random . rays . time
Fractal 068 A | Time
Fractal 068 A zoom1

Fractal 068 A – zoom level 1

Fractal 068 A zoom2

Fractal 068 A – zoom level 2

Data

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, please contact Philippe.

Fractal 068 A - Time - Part of OUTER SPACE series - 02.2022

Fractal 068 A | Time

Fractal_■■■_A {
fractal:
  title="Fractal_■■■_A" width=■■■■ height=■■■■ layers=■
  credits="Philoxerax;■/■■/■■■■"
layer:
  caption="Background" opacity=■■ mergemode=screen precision=■
mapping:
  center=-■■.■■■■■■■■■■/-■.■■■■■■■■■■ magn=■.■■■■■■■■ angle=■■■.■■■■
formula:
  maxiter=■■■ percheck=off filename="asz.ufm" entry="andrextrandom-■"
  p_base=-■.■■/-■.■ p_base■=■.■■/■.■■ p_random_strength=■.■
  p_bailout=■E■ p_bailout_mode="|z/c|" p_zc_mode=Multiply
  p_zc_absolute=no p_zc_inverse=no p_ztype=Real p_scatter=yes
  f_function■=cos f_function■=ident
inside:
  transfer=none solid=■■■■■■■■■■
outside:
  transfer=linear
gradient:
  smooth=yes rotation=■■■ index=■■■ color=■ index=■■■ color=■■■■■■■■
  index=■■■ color=■■■■■■■■ index=■■■ color=■■■■■■■■ index=■■■
  color=■■■■■■■■ index=■■■ color=■■■■■■■■ index=■■■ color=■■■■■■■
  index=■■■ color=■■■■■■■■ index=■■■ color=■■■■■■
opacity:
  smooth=no index=■ opacity=■■■
layer:
  caption="Background" opacity=■■■ visible=no mergemode=addition
mapping:
  center=-■.■■■■■■■■■■■■/-■.■■■■■■■■■■■■■ magn=■■■.■■■■■ angle=■■.■■■■
formula:
  maxiter=■■■ percheck=off filename="lkm■.ufm"
  entry="rotated-mandelbrot" p_manparam=■/■ p_power=■/■ p_bailout=■■■■
  p_rottype="before iterating" p_rotfac=■ p_angletype=z
inside:
  transfer=none
outside:
  transfer=linear
gradient:
  smooth=yes rotation=-■■■ index=■ color=■■■■■■■ index=■■
  color=■■■■■■■■ index=■■■ color=■■■■■■■■ index=-■■■ color=■■■
opacity:
  smooth=no index=■ opacity=■■■
layer:
  caption="Background" opacity=■■■ mergemode=addition
mapping:
  center=-■.■■■■■■■■■■■■■/■.■■■■■■■■■■■■■ magn=■■■■.■■■■
  angle=■■■.■■■■
formula:
  maxiter=■■■ filename="lkm■.ufm"
  entry="mixed-up-multiplication-mandelbrot" p_power=■ p_bailout=■■■■
  p_shape_type=square p_q■_type=out p_q■_type=out p_q■_type=out
  p_q■_type=out p_freq=■ p_amp=■.■ p_nteeth=■ p_rsmall=■.■
  p_inrad=■.■■
inside:
  transfer=none
outside:
  transfer=linear
gradient:
  smooth=yes rotation=-■■ index=■■ color=■■■■■■■ index=■■■ color=■
  index=■■■ color=■■■■■■■ index=■■■ color=■■■■■■■■ index=-■■ color=■
  index=-■ color=■■■■■■■■
opacity:
  smooth=no index=■ opacity=■■■
layer:
  caption="Layer ■" opacity=■■■
mapping:
  center=-■.■■■■■■■■■■■■■■/■.■■■■■■■■■■■■■ magn=■■■■.■■■
  angle=■■■.■■■■
formula:
  maxiter=■■■ filename="lkm■.ufm"
  entry="mixed-up-multiplication-mandelbrot" p_power=■ p_bailout=■■■■
  p_shape_type=square p_q■_type=out p_q■_type=out p_q■_type=out
  p_q■_type=out p_freq=■ p_amp=■.■ p_nteeth=■ p_rsmall=■.■
  p_inrad=■.■■
inside:
  transfer=none solid=■■■■■■■■■■
outside:
  transfer=linear
gradient:
  smooth=yes rotation=-■■ index=■ color=■ index=■■ color=■■■■■■■
  index=■■■ color=■■■■■■■ index=■■■ color=■■■■■■■■ index=■■■
  color=■■■■■■■ index=■■■ color=■■■■■■■ index=-■■ color=■■■■■■■
opacity:
  smooth=no index=■ opacity=■■■
}

andrextrandom-■{ ;(c) by Andras Szolek
; The formula is the same as Andrextrandom-■, only the
; defaults are the different. I made two for the easy
; switching.

init:
  z = #pixel
  random = z+(#random/(■/(@random_strength/■■■)))
  c = z-#pixel^■/■+@base■@base■+■.■■
  zc = ■

 if @zc_mode == ■
  zc = z■c
 elseif @zc_mode == ■
  zc = z/c
 elseif @zc_mode == ■
  zc = z+c
 elseif @zc_mode == ■
  zc = z-c
 elseif @zc_mode == ■
  zc = z^c
 endif

 if @zc_mode == ■ && @zc_inverse == true
  zc = c/z
 elseif @zc_mode == ■ && @zc_inverse == true
  zc = c-z
 elseif @zc_mode == ■ && @zc_inverse == true
  zc = c^z
 endif

 if @zc_absolute == true
  zc = |zc|
 endif

 b = ■

loop:

  z = z/(@function■(random))/(zc)+@base
  z = z■(zc)+random
  c = (z+c)■■+@base

  z = @function■(z■(sqrt(c■@base■)/@bailout)+zc)

 if @scatter == true
  z = z+((@base■-@base)/■■■)+zc
  c = c-((c/flip(c))/(c■real(c)))-zc
 endif

 if imag(z)>■
  z = real(z+@base)
 elseif imag(z)>■
  z = flip(z+@base)
 elseif imag(z)<■
  z = imag(z+@base)
 elseif real(z)>■
  z = flip(z+@base)
 elseif real(z)>■
  z = real(z+@base)
  endif
  
 if @scatter == true
 if real(z)■imag(z) < flip(z)
  z = real(z)/imag(z)
 endif
 endif

 if @ztype == ■
  z = real(z)
 elseif @ztype == ■
  z = imag(z)
 endif

 if @bailout_mode == ■
  b = z■c
 elseif @bailout_mode == ■
  b = |z■c|
 elseif @bailout_mode == ■
  b = z/c
 elseif @bailout_mode == ■
  b = |z/c|
 elseif @bailout_mode == ■
  b = z+c
 elseif @bailout_mode == ■
  b = |z■c|
 elseif @bailout_mode == ■
  b = z-c
 elseif @bailout_mode == ■
  b = |z-c|
 elseif @bailout_mode == ■
  b = z
 elseif @bailout_mode == ■
  b = |z|
 elseif @bailout_mode == ■■
  b = c
 elseif @bailout_mode == ■■
  b = |c|
 else
  b = z■c
 endif

bailout:
  b <= @bailout/■■

default:
 title = "Andrextrandom - Switch #■"

 param base
  caption = "Base, ''Seed'' #■"
  default = (-■.■■,-■.■)
 endparam

 param base■
  caption = "Base, ''Seed'' #■"
  default = (■.■■,■.■■)
  endparam

 param random_strength
  caption = "Random-intensity"
  default = ■.■
  min = ■.■
 endparam

 param bailout
  caption = "Bailout"
  default = ■E■
 endparam

 param bailout_mode
  caption = "Bailout Mode"
  hint = "The bailout-process : ''this value'' < \
  ''bailout parameter /variant/''"
  enum = "z■c" "|z■c|" "z/c" "|z/c|" "z+c" "|z+c|"\
  "z-c" "|z-c|" "z" "|z|" "c" "|c|"
  default = ■
 endparam

 param zc_mode
  caption = "ZC - Mode"
  enum = "Multiply" "Division" "Add" "Subtract"\
  "Product"
 endparam

 param zc_absolute
  caption = "ZC - Absolute"
  hint = "It gives an absolute-result to the z ? c"
  default = false
 endparam

 param zc_inverse
  caption = "ZC - Inverse"
  hint = "This function is working in ''Division'', \
  ''Subtract'' and ''Product'' ZC-Modes. How does \
  it works? z/c -> c/z, z-c -> c-z and z^c -> c^z"
  default = false
 endparam

 param ztype
  caption = "Z Type"
  enum = "Real" "Imag"
 endparam

 param scatter
  caption = "Scatter"
  default = true
 endparam

 func function■
  caption = "Function #■"
  default = cos()
 endfunc

 func function■
  caption = "Function #■"
  default = ident()
 endfunc

 periodicity = ■

switch:
 type = "andrextrandom-■"
 base = #pixel
 random_strength = random_strength
 bailout = bailout
 bailout_mode = bailout_mode
 zc_mode = zc_mode
 zc_absolute = zc_absolute
 zc_inverse = zc_inverse
 ztype = ztype
 scatter = scatter
 function■ = function■
 function■ = function■
}

rotated-mandelbrot { ; Kerry Mitchell ■■oct■■■■
;
; Rotates the z variable in the standard Mandelbrot
; calculation each iteration.
;
; Use the 'rotation type' parameter to rotate before or 
; after raising z to the desired power, or both before and 
; after.  The '+before, -after' setting rotates the opposite
; way after raising z to the power.
;
; The rotation angle is the 'rotation factor' times the angle
; of the pixel or z.  The 'constant' setting in 'rotation type'
; makes the rotational angle a constant 'rotation factor'
; degrees.
;
init:
  c=#pixel
  z=c+@manparam
  float t=■.■
  float trad=@rotfac■#pi/■■■
  rot=(■,■)
loop:
;
; set up the rotation angle
;
  if(@angletype==■)          ; pixel
    t=@rotfac■atan■(#pixel)
  elseif(@angletype==■)      ; z
    t=@rotfac■atan■(z)
  else                       ; constant
    t=trad
  endif
  rot=cos(t)+flip(sin(t))
;
; iterate z, taking into account the rotation type
;
  if(@rottype==■)            ; before
    z=z■rot
    z=z^@power+c
  elseif(@rottype==■)        ; after
    z=z^@power+c
    if(@angletype==■)
      t=@rotfac■atan■(z)
      rot=cos(t)+flip(sin(t))
    endif
    z=z■rot
  elseif(@rottype==■)        ; before & after
    z=z■rot
    z=z^@power+c
    if(@angletype==■)
      t=@rotfac■atan■(z)
      rot=cos(t)+flip(sin(t))
    endif
    z=z■rot
  elseif(@rottype==■)        ; +before, -after
    z=z■rot
    z=z^@power+c
    if(@angletype==■)
      t=@rotfac■atan■(z)
      rot=cos(t)+flip(sin(t))
    endif
    z=z/rot
  else                       ; none
    z=z^@power+c
  endif
bailout:
  |z|<@bailout
default:
  title="Rotated Mandelbrot"
  periodicity=■
  param manparam
    caption="perturbation"
    default=(■,■)
  endparam
  param power
    caption="power"
    default=(■,■)
  endparam
  float param bailout
    caption="bailout"
    default=■■■■.■
  endparam
  param rottype
    caption="rotation type"
    default=■
    enum="none" "before iterating" "after iterating" \
      "before & after" "+before, -after"
    hint="How z is rotated each iteration."
  endparam
  float param rotfac
    caption="rotation factor"
    default=■.■
    enabled=@rottype!="none"
    hint="If 'angle type' is 'constant', then this is the \
      rotation angle in degrees. Otherwise, it is the factor \
      that multiples the pixel or z angle to make the rotation \
      angle."
  endparam
  param angletype
    caption="angle type"
    default=■
    enum="constant" "pixel" "z"
    enabled=@rottype!="none"
    hint="Use 'constant' to specify a constant angle in degrees. \
      Otherwise, the rotation is based on the angle of the pixel \
      or the angle of z."
  endparam
switch:
  type="rotated-julia"
  julparam=#pixel
  bailout=bailout
  power=power
  rottype=rottype
  rotfac=rotfac
  angletype=angletype
}

mixed-up-multiplication-mandelbrot { ; Kerry Mitchell ■■Nov■■■■
;
; Instead of using regular complex multiplication, this method uses a base
; shape (= unit circle normally). Use the polar angle of z to reach back
; to the base shape and find its coordinates. Then, use the actual and base
; magnitudes to determine a scale factor, and the arc length to determine
; the angle (angle = arc length / base magnitude). From there, the magnitude
; of z^power = scale factor ^ power, and angle of z^power = power ■ angle.
;
$define debug
global:
  complex corner[■■]
  float pitch_s=■
  float pitch_trad=■
  float smax=■
  float tdegmax[■■]
  float twopi=■■#pi
  int gi=■
;
; cruciform settings: central square side & four other squares, one
; on each side of central square
;
  if(@shape_type=="cruciform")
    corner[■]=(■,■)
    corner[■]=(■,■)
    corner[■]=(■,■)
    corner[■]=(■,■)
    corner[■]=(-■,■)
    corner[■]=(-■,■)
    corner[■]=(-■,■)
    corner[■]=(-■,-■)
    corner[■]=(-■,-■)
    corner[■]=(-■,-■)
    corner[■■]=(■,-■)
    corner[■■]=(■,-■)
    corner[■■]=(■,-■)
    corner[■■]=(■,■)
;
;   rescale so that corner[■] = (■,■)
;   find degree measures of corners
;
    gi=-■
    while(gi<■■)
      gi=gi+■
      corner[gi]=corner[gi]/■
      tdegmax[gi]=(atan■(corner[gi])/#pi■■■■+■■■)%■■■
    endwhile
  elseif(@shape_type=="triangle")
    corner[■]=(■,■)
    corner[■]=(-■+flip(sqrt(■)))/■
    corner[■]=(-■-flip(sqrt(■)))/■
    tdegmax[■]=■
    tdegmax[■]=■■■
    tdegmax[■]=■■■
    tdegmax[■]=■■■
  elseif(@shape_type=="star")
    corner[■]=(■,■)
    corner[■]=@inrad■(■,■)/sqrt(■)
    corner[■]=(■,■)
    corner[■]=@inrad■(-■,■)/sqrt(■)
    corner[■]=(-■,■)
    corner[■]=@inrad■(-■,-■)/sqrt(■)
    corner[■]=(■,-■)
    corner[■]=@inrad■(■,-■)/sqrt(■)
    corner[■]=(■,■)
    tdegmax[■]=■
    tdegmax[■]=■■
    tdegmax[■]=■■
    tdegmax[■]=■■■
    tdegmax[■]=■■■
    tdegmax[■]=■■■
    tdegmax[■]=■■■
    tdegmax[■]=■■■
    tdegmax[■]=■■■
  endif
;
; gear settings
;
  if(@shape_type=="gear")
    pitch_trad=twopi/@nteeth
    smax=#pi■(■+@rsmall)
    pitch_s=smax/@nteeth
  endif
init:
  complex arccenter=(■,■)
  complex c=#pixel
  complex compk=(■,■)
  complex w=(■,■)
  complex z=#pixel
  float afac=■
  float bfac=■
  float cfac=■
  float dcrit=■/(■+@rsmall)
  float dtooth=■
  float h■=■
  float k■=■
  float k=■
  float phi=■
  float phimax=■
  float r=■
  float s=■
  float slope=■
  float tdeg=■
  float third=■/■
  float trad=■
  float x=■
  float xb=■
  float x■=■
  float y=■
  float yb=■
  float y■=■
  int itooth=■
loop:
;
; decompose z
;
  x=real(z), y=imag(z)
;
; square
;
  if(@shape_type=="square")
;
;   determine arc length from basis shape
;
    phimax=■
;
;   find scale factor k
;
    k=abs(x)
    if(abs(y)>k)
      k=abs(y)
    endif
;
;   find standard polar angle
;
    trad=atan■(z)
    if(trad<■)
      trad=trad+■■#pi
    endif
    tdeg=trad/#pi■■■■
;
;   use polar angle to find coordinates of point on base shape
;   and base shape arc length
;
    if(tdeg<■■) ; upper right side
      xb=■, yb=y/k, s=yb
    elseif(tdeg<■■■) ; top
      xb=x/k, yb=■, s=■-xb
    elseif(tdeg<■■■) ; left side
      xb=-■, yb=y/k, s=■-yb
    elseif(tdeg<■■■) ; bottom
      xb=x/k, yb=-■, s=■+xb
    else ; lower right side
      xb=■, yb=y/k, s=■+yb
    endif
    phi=s
;
;   raise z to power
;
    k=k^@power, phi=(@power■phi)%phimax
;
;   use phi and k to return new x & y and add c
;
    if(phi<■) ; upper right side
      xb=■, yb=phi
    elseif(phi<■) ; top
      xb=■-phi, yb=■
    elseif(phi<■) ; left side
      xb=-■, yb=■-phi
    elseif(phi<■) ; bottom
      xb=phi-■, yb=-■
    else ; lower right side
      xb=■, yb=phi-■
    endif
    x=xb■k, y=yb■k
    z=x+flip(y)+c
;
; triangle
;
  elseif(@shape_type=="triangle")
;
;   determine arc length from basis shape
;
    third=sqrt(■)
    phimax=■■third
;
;   find standard magnitude and polar angle
;
    r=cabs(z)
    trad=atan■(z)
    tdeg=(trad/#pi■■■■+■■■)%■■■
    trad=tdeg/■■■■#pi
;
;   use polar angle to find coordinates of point on base shape
;   and base shape arc length
;
    if(tdeg
not generated by AI logo