comment {
  Métodos para colorear
  Por Marcelo Anelli C.
  Caracas, Venezuela, 1999.
}

Azar01 { ; Marcelo Anelli
  init:
    complex dummy = srand(@p1)
  final:
    dummy = dummy +1
    #index = @ampli * #numiter + cabs( #rand * @factor )
default:
  title = "Random"
  param p1
    caption = "Seed"
    hint = "UF program does not use this parameters, sorry"
    default = 1
  endparam
  param ampli
    caption = "Normal component"
    default = 0.01
  endparam
  param factor
    caption = "Random component"
    default = 1.0
  endparam
}

Amplitud { ; Marcelo Anelli
  init:
    float dmax = -1E60
    float dmin = 1E60
  loop:
    float d = cabs(#z)
    if (d < dmin)
      dmin = d
    endif
    if (d > dmax)
      dmax = d
    endif
  final:
    float x=real(#z)
    float y=imag(#z)
    if(@colorear==1)
      float t=atan2(#z)
      t=t/pi
      if(t<0.0)
        t=t+2.0
      endif
      #index=cabs(@gradi(@ampli * t))
    elseif(@colorear==2)      ; magnitude
      #index=cabs(@gradi(@ampli * #z))
    elseif(@colorear==3)      ; real(z)
      #index=cabs(@gradi(@ampli * x))
    elseif(@colorear==4)      ; imag(z)
      #index=cabs(@gradi(@ampli * y))
    elseif(@colorear==5)
      #index=cabs(@gradi(@ampli * dmax))
    elseif(@colorear==6)
      #index=cabs(@gradi(@ampli * dmin))
    elseif(@colorear==7)
      #index=cabs(@gradi(@ampli * cabs(#pixel)))
    else
      #index = cabs(@gradi(@ampli * #numiter))
    endif
default:
  title = "Amplitud"
  param ampli
    caption = "Height"
    default = 0.01
  endparam
  param colorear
    caption = "coloring"
    default = 0
    enum = \
      "iteration" \
      "angle" \
      "|z|" \
      "real(z)" \
      "imag(z)" \
      "|z| max" \
      "|z| min" \
      "pixel"
  endparam
  func gradi
    caption = "Transform"
    default = ident()
  endfunc
}

Azar02 { ; Marcelo Anelli
  init:
    complex dummy = srand(@p1)
    float dmax = -1E60
    float dmin = 1E60
  loop:
    float d = cabs(#z)
    if (d < dmin)
      dmin = d
    endif
    if (d > dmax)
      dmax = d
    endif
  final:
    dummy = dummy +1
    float x=real(#z)
    float y=imag(#z)
    if(@colorear==1)
      float t=atan2(#z)
      t=t/pi
      if(t<0.0)
        t=t+2.0
      endif
      #index=cabs(@gradi(@ampli*t+ #rand * @factor ))
    elseif(@colorear==2)      ; magnitude
      #index=cabs(@gradi(@ampli*cabs(#z)+ #rand * @factor ))
    elseif(@colorear==3)      ; real(z)
      #index=cabs(@gradi(@ampli*x+ #rand * @factor ))
    elseif(@colorear==4)      ; imag(z)
      #index=cabs(@gradi(@ampli*y+ #rand * @factor ))
    elseif(@colorear==5)
      #index=cabs(@gradi(@ampli*dmax + #rand * @factor ))
    elseif(@colorear==6)
      #index=cabs(@gradi(@ampli*dmin + #rand * @factor ))
    elseif(@colorear==7)
      #index=cabs(@gradi(@ampli * cabs(#pixel) + #rand * @factor ))
    else
      #index=cabs(@gradi(@ampli*#numiter + #rand * @factor ))
    endif
default:
  title = "Azar por Amplitud"
  param ampli
    caption = "Height"
    default = 0.1
  endparam
  param colorear
    caption = "coloring"
    default = 0
    enum = \
      "iteration" \
      "angle" \
      "|z|" \
      "real(z)" \
      "imag(z)" \
      "|z| max" \
      "|z| min" \
      "pixel"
  endparam
  param p1
    caption = "Seed"
    hint = "UF program does not use this parameters, sorry"
    default = 1
  endparam
  param factor
    caption = "Factor"
    default = 0.1
  endparam
  func gradi
    caption = "Transform"
    default = ident()
  endfunc
}

Cuadratico { ; Marcelo Anelli
; basado en la ecuación ax*x+bx+c
; based on the quadratic equation ax*x+bx+c
  init:
    float dmax = -1E60
    float dmin = 1E60
  loop:
    float d = cabs(#z)
    if (d < dmin)
      dmin = d
    endif
    if (d > dmax)
      dmax = d
    endif
  final:
    float x=real(#z)
    float y=imag(#z)
    float m=cabs(#z)
    if(@colorear==1)
      float t=atan2(#z)
      t=t/pi
      if(t<0.0)
        t=t+2.0
      endif
      #index=cabs(@gradi(@a*t*t + @b*t + @c ))
    elseif(@colorear==2)      ; magnitude
      #index=cabs(@gradi(@a*m*m + @b*m + @c))
    elseif(@colorear==3)      ; real(z)
      #index=cabs(@gradi(@a*x*x+ @b*x + @c ))
    elseif(@colorear==4)      ; imag(z)
      #index=cabs(@gradi(@a*y*y+ @b*y + @c))
    elseif(@colorear==5)
      #index=cabs(@gradi(@a*dmax*dmax + @b*dmax + @c ))
    elseif(@colorear==6)
      #index=cabs(@gradi(@a*dmin*dmin + @b*dmin + @c ))
    elseif(@colorear==7)
      #index=cabs(@gradi(@a*cabs(#pixel) + @b*cabs(#pixel) + @c ))
    else
      #index=cabs(@gradi(@a * #numiter * #numiter + @b * #numiter + @c))
    endif
default:
  title = "Cuadrático"
  param colorear
    caption = "coloring"
    default = 0
    enum = \
      "iteration" \
      "angle" \
      "|z|" \
      "real(z)" \
      "imag(z)" \
      "|z| max" \
      "|z| min" \
      "pixel"
  endparam
  param a
    caption = "Constant a"
    default = 0.01
  endparam
  param b
    caption = "Constant b"
    default = 0.01
  endparam
  param c
    caption = "Constant c"
    default = 0.01
  endparam
  func gradi
    caption = "Transform"
    default = ident()
  endfunc
}

Trovata { ; Marcelo Anelli
  init:
    float dmax = -1E60
    float dmin = 1E60
    complex zmax = (0.0,0.0)
    complex zmin = (0.0,0.0)
  loop:
    float d = cabs(#z - @center)
      if (d < dmin)
        dmin = d
        zmin = #z
    endif
      if (d > dmax)
        dmax = d
        zmax = #z
    endif
  final:
    if(@colorear==1)
      float t=atan2(#z - @center)
      t=t/pi
      if(t<0.0)
        t=t+2.0
      endif
      #index=@ampli*cabs(@gradi((t - |@center|)))
    elseif(@colorear==2)      ; magnitude
      #index=@ampli*cabs(@gradi((#z - @center)))
    elseif(@colorear==3)      ; real(z)
      #index=@ampli*cabs(@gradi((real(#z - @center))))
    elseif(@colorear==4)      ; imag(z)
      #index=@ampli*cabs(@gradi((imag(#z - @center))))
   elseif(@colorear==5)
      #index=@ampli*cabs(@gradi((zmax - @center)))
    elseif(@colorear==6)
      #index=@ampli*cabs(@gradi((zmin - @center)))
    elseif(@colorear==7)
      #index=@ampli*cabs(@gradi((#pixel - @center)))
    elseif(@colorear==8)
      ; From Gaussian Integer developed by Kerry Mitchell
      #index=@ampli*cabs(@gradi(round(#z/@center) ))
    else
      #index=@ampli*cabs(@gradi((#numiter - @center)))
    endif
default:
  title = "Trovata"
  param ampli
    caption = "Height"
    default = 0.1
  endparam
  param colorear
    caption = "coloring"
    default = 0
    enum = \
      "iteration" \
      "angle" \
      "|z|" \
      "real(z)" \
      "imag(z)" \
      "|z| max" \
      "|z| min" \
      "pixel" \
      "Gaussian integer" 
  endparam
  param center
    caption = "Point of application"
    default = (0.0, 0.0)
  endparam
  func gradi
    caption = "Transform"
    default = ident()
  endfunc
}

ApplyFunc01 {
  init:
   complex z1 = #z
    float dmax = -1E60
    float dmin = 1E60
    complex zmax = (0.0,0.0)
    complex zmin = (0.0,0.0)
  loop:
    ; type 0: z = fn(z + center) / fn(z - center)
    ; type 1: z = fn( z ) + fn( z/center) + fn(center)
    ; type 2: z = fn( z*z ) + fn( 2*z*center) + fn( center*center)
    if (@typecal== 0)
      z1 = @fn1(#z + @center) / @fn1(#z - @center)
    elseif (@typecal== 1)
      z1 = @fn1(#z) / @fn1(#z / @center) + @fn1(@center)
    elseif (@typecal== 2)
      z1 = @fn1(#z*#z) / @fn1(2*#z*@center) + @fn1(@center*@center)
    endif
    float d = cabs(z1 - @center)
      if (d < dmin)
      dmin = d
      zmin = z1
     endif
      if (d > dmax)
        dmax = d
      zmax = z1
    endif
  final:
    if(@colorear==1)
      float t=atan2(z1 - @center)
      t=t/pi
      if(t<0.0)
        t=t+2.0
      endif
      #index=@ampli*cabs(@gradi((t - |@center|)))
    elseif(@colorear==2)      ; magnitude
      #index=@ampli*cabs(@gradi((z1 - @center)))
    elseif(@colorear==3)      ; real(z)
      #index=@ampli*cabs(@gradi((real(z1 - @center))))
    elseif(@colorear==4)      ; imag(z)
      #index=@ampli*cabs(@gradi((imag(z1 - @center))))
   elseif(@colorear==5)
      #index=@ampli*cabs(@gradi((zmax - @center)))
    elseif(@colorear==6)
      #index=@ampli*cabs(@gradi((zmin - @center)))
    elseif(@colorear==7)
      #index=@ampli*cabs(@gradi((#pixel - @center)))
    elseif(@colorear==8)
      ; From Gaussian Integer developed by Kerry Mitchell
      #index=@ampli*cabs(@gradi(round(z1/@center) ))
    else
      #index=@ampli*cabs(@gradi((#numiter - @center)))
    endif
default:
  title = "ApplyFunc01"
  param ampli
    caption = "Height"
    default = 0.1
  endparam
  param typecal
    caption = "Calculation"
    default = 0
    enum = "Type 0" "Type 1" "Type 2"
    ; type 0: z = fn(z + center) / fn(z - center)
    ; type 1: z = fn( z ) + fn( z/center) + fn(center)
    ; type 2: z = fn( z*z ) + fn( 2*z*center) + fn( center*center)
  endparam
  param colorear
    caption = "coloring"
    default = 0
    enum = \
    "iteration" "angle" "|z|" "real(z)" "imag(z)" \
      "|z| max" "|z| min" "pixel" "Gaussian integer" 
  endparam
  param center
    caption = "Point of application"
    default = (0.0, 0.0)
  endparam
  func gradi
    caption = "Transform"
    default = ident()
  endfunc
  func fn1
    caption = "Function applied"
    default = ident()
  endfunc
}

CheckerBoard { ; Marcelo Anelli
  ; Caution!!:
  ; this method does not work with fast Mandel and fast Julia.
  init:
    float p = 0.0
    float w = 320 / #width * 0.03 * sqrt(@p1)
    int tx = 0
    int ty = 0
    float rx = real( #screenpixel )
    float ry = imag( #screenpixel )
    tx = floor( rx * w )
    if @ratio
      ty = floor( ry * w * #width / #height )
    else
      ty = floor( ry * w )
    endif
    int t = ( tx + ty ) % 2
    if (t == 0)
      p = @pmin
    else
      p = @pmax
    endif
  final:
    #index = p
default:
  title = "CheckerBoard"
  param p1
    caption = "Width"
    default = 1.0
    hint = "Not depending of magnification."
  endparam
  param ratio
    default = false
    caption = "Aspect ratio"
    hint = "Enable to match the aspect ratio of the square and the image"
  endparam
  param pmin
    caption = "White Square Color"
    min = 0.0
    max = 1.0
    default = 0.1
  endparam
  param pmax
    caption = "Black Square Color"
    min = 0.0
    max = 1.0
    default = 0.7
  endparam
}

potential { ; Marcelo Anelli
; Equipotential curves
init:
  float gc = 0.0
  complex z1 = (0.0, 0.0)
final:
  z1 = #z - @center
  if (@form==0) || (@form==1) || (@form==4)
    gc = cabs( @fn1( cabs( z1 ))) / ( 2 ^ #numiter )
  elseif (@form==2) || (@form==3) || (@form==5)
    gc = cabs( @fn1( z1 )) / ( 2 ^ #numiter )
  elseif (@form==6) || (@form==7)
    gc = cabs( @fn1( #pixel )) / ( 2 ^ #numiter )
  endif
  if (@form == 0) || (@form==2) || (@form==6)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 1) || (@form==3) || (@form==7)
    #index = cabs(( 0.5 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 4) || (@form==5)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )) - \
             round( cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )))
  endif
default:
  title = "Potential"
  param center
    caption = "Point of application"
    default = (0.0, 0.0)
  endparam
  param form
    caption = "Potential form"
    default = 0
    enum = "G(c)" "CPM" "G(c) alt" "CPM alt" "RCPM" "RCPM alt" \
           "G(p)" "CPP"
  endparam
  func fn1
    default = log()
    caption = "Funcion 1"
  endfunc
  func fn2
    default = log()
    caption = "Funcion 2"
  endfunc
}

Dpotential { ; Marcelo Anelli
; Equipotential curves Doubled
init:
  float gc = 0.0
  complex z1 = (0.0, 0.0)
  complex z2 = (0.0, 0.0)
final:
  z1 = #z - @center
  z2 = z1 * z1
  if (@form==0) || (@form==1) || (@form==4)
    gc = cabs( @fn1( cabs( z1 )) + @fn1( cabs( z2 ))) / ( 2 ^ #numiter )
  elseif (@form==2) || (@form==3) || (@form==5)
    gc = cabs( @fn1( z1 ) + @fn1( z2 )) / ( 2 ^ #numiter )
  elseif (@form==6) || (@form==7)
    gc = cabs( @fn1( #pixel ) + @fn1( z2 )) / ( 2 ^ #numiter )
  endif
  if (@form == 0) || (@form==2) || (@form==6)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 1) || (@form==3) || (@form==7)
    #index = cabs(( 0.5 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 4) || (@form==5)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )) - \
             round( cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )))
  endif
default:
  title = "Double Potential"
  param center
    caption = "Point of application"
    default = (0.0, 0.0)
  endparam
  param form
    caption = "Potential form"
    default = 0
    enum = "G(c)" "CPM" "G(c) alt" "CPM alt" "RCPM" "RCPM alt" \
           "G(p)" "CPP"
  endparam
  func fn1
    default = log()
    caption = "Funcion 1"
  endfunc
  func fn2
    default = log()
    caption = "Funcion 2"
  endfunc
}

Rpotential { ; Marcelo Anelli
; Equipotential curves by ratio
init:
  float gc = 0.0
  complex z1 = (0.0, 0.0)
final:
  z1 = #z - @center
  if (@form==0) || (@form==1) || (@form==4)
    gc = cabs( @fn1( cabs( z1 )) / z1 ) / ( 2 ^ #numiter )
  elseif (@form==2) || (@form==3) || (@form==5)
    gc = cabs( @fn1( z1 ) / z1 ) / ( 2 ^ #numiter )
  elseif (@form==6) || (@form==7)
    gc = cabs( @fn1( #pixel ) / z1 ) / ( 2 ^ #numiter )
  endif
  if (@form == 0) || (@form==2) || (@form==6)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 1) || (@form==3) || (@form==7)
    #index = cabs(( 0.5 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 4) || (@form==5)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )) - \
             round( cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )))
  endif
default:
  title = "Ratio Potential"
  param center
    caption = "Point of application"
    default = (0.0, 0.0)
  endparam
  param form
    caption = "Potential form"
    default = 0
    enum = "G(c)" "CPM" "G(c) alt" "CPM alt" "RCPM" "RCPM alt" \
           "G(p)" "CPP"
  endparam
  func fn1
    default = log()
    caption = "Funcion 1"
  endfunc
  func fn2
    default = log()
    caption = "Funcion 2"
  endfunc
}

Ipotential { ; Marcelo Anelli
; Equipotential curves inverted
init:
  float gc = 0.0
  complex z1 = (0.0, 0.0)
final:
  z1 = 1/ (#z - @center)
  if (@form==0) || (@form==1) || (@form==4)
    gc = cabs( @fn1( cabs( z1 ))) / ( 2 ^ #numiter )
  elseif (@form==2) || (@form==3) || (@form==5)
    gc = cabs( @fn1( z1 )) / ( 2 ^ #numiter )
  elseif (@form==6) || (@form==7)
    gc = cabs( @fn1( 1 / #pixel )) / ( 2 ^ #numiter )
  endif
  if (@form == 0) || (@form==2) || (@form==6)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 1) || (@form==3) || (@form==7)
    #index = cabs(( 0.5 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 4) || (@form==5)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )) - \
             round( cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )))
  endif
default:
  title = "Reciproc Potential"
  param center
    caption = "Point of application"
    default = (0.0, 0.0)
  endparam
  param form
    caption = "Potential form"
    default = 0
    enum = "G(c)" "CPM" "G(c) alt" "CPM alt" "RCPM" "RCPM alt" \
           "G(p)" "CPP"
  endparam
  func fn1
    default = log()
    caption = "Funcion 1"
  endfunc
  func fn2
    default = log()
    caption = "Funcion 2"
  endfunc
}

Epotential { ; Marcelo Anelli
; Equipotential curves by difference
init:
  float gc = 0.0
  complex z1 = (0.0, 0.0)
  complex z_values[#maxiter + 1]
  z_values[0] = #z
  int i = 0
loop:
  i = i+1
  z_values[i] = #z  
final:
  if (#numiter > 1)
    z1 = z_values[#numiter] - z_values[#numiter-1]
  else
    z1 = z_values[#numiter]
  endif
  z1 = (z1 - @center)
  if (@form==0) || (@form==1) || (@form==4)
    gc = cabs( @fn1( cabs( z1 ))) / ( 2 ^ #numiter )
  elseif (@form==2) || (@form==3) || (@form==5)
    gc = cabs( @fn1( z1 )) / ( 2 ^ #numiter )
  elseif (@form==6) || (@form==7)
    gc = cabs( @fn1( #pixel )) / ( 2 ^ #numiter )
  endif
  if (@form == 0) || (@form==2) || (@form==6)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 1) || (@form==3) || (@form==7)
    #index = cabs(( 0.5 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 4) || (@form==5)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )) - \
             round( cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )))
  endif
default:
  title = "Differential Potential"
  param center
    caption = "Point of application"
    default = (0.0, 0.0)
  endparam
  param form
    caption = "Potential form"
    default = 0
    enum = "G(c)" "CPM" "G(c) alt" "CPM alt" "RCPM" "RCPM alt" \
           "G(p)" "CPP"
  endparam
  func fn1
    default = log()
    caption = "Funcion 1"
  endfunc
  func fn2
    default = log()
    caption = "Funcion 2"
  endfunc
}

Fpotential { ; Marcelo Anelli
; Equipotential curves by squared sums
init:
  float gc = 0.0
  complex z1 = (0.0, 0.0)
  complex z_values[#maxiter + 1]
  z_values[0] = #z
  int i = 0
loop:
  i = i+1
  z_values[i] = #z  
final:
  int iter = 1
  while iter <= #numiter
    z1 = z1 + z_values[#numiter] * z_values[#numiter]
    iter = iter + 1
  endwhile
  z1 = (z1 / #numiter - @center)
  if (@form==0) || (@form==1) || (@form==4)
    gc = cabs( @fn1( cabs( z1 ))) / ( 2 ^ #numiter )
  elseif (@form==2) || (@form==3) || (@form==5)
    gc = cabs( @fn1( z1 )) / ( 2 ^ #numiter )
  elseif (@form==6) || (@form==7)
    gc = cabs( @fn1( #pixel )) / ( 2 ^ #numiter )
  endif
  if (@form == 0) || (@form==2) || (@form==6)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 1) || (@form==3) || (@form==7)
    #index = cabs(( 0.5 * @fn2( gc ) / @fn2( 2.0 ) ))
  elseif (@form == 4) || (@form==5)
    #index = cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )) - \
             round( cabs(( -1 * @fn2( gc ) / @fn2( 2.0 ) )))
  endif
default:
  title = "Potential of squared sum"
  param center
    caption = "Point of application"
    default = (0.0, 0.0)
  endparam
  param form
    caption = "Potential form"
    default = 0
    enum = "G(c)" "CPM" "G(c) alt" "CPM alt" "RCPM" "RCPM alt" \
           "G(p)" "CPP"
  endparam
  func fn1
    default = log()
    caption = "Funcion 1"
  endfunc
  func fn2
    default = log()
    caption = "Funcion 2"
  endfunc
}

Lines { ; Marcelo Anelli
init:
  float r2 = 0.0
  float dmin = 1e20
  float dmax = -1e20
  complex z_values[#maxiter + 1]
  z_values[0] = #z
  int i = 0
loop:
  i = i+1
  z_values[i] = #z  
final:
  int iter = 1
  while iter <= #numiter
    if (dmin > |z_values[#numiter]|)
      dmin = |z_values[#numiter]|
    endif
    if (dmax < |z_values[#numiter]|)
      dmax = |z_values[#numiter]|
    endif
    iter = iter + 1
  endwhile
  if (@forma==0)
    r2 = cabs( @fn2( cabs( real( #z ) / imag( #z ) )) * \
         @fn2( cabs( imag( #z ) / real( #z ) ))) * @f1
  elseif (@forma==1)
    r2 = cabs( @fn2( cabs( real( #z ) / imag( #z ) ))) * @f1
  elseif (@forma==2)
    r2 = cabs( @fn2( cabs( imag( #z ) / real( #z ) ))) * @f1
  elseif (@forma==3)
    r2 = cabs( @fn2( real( #z ) * real( #z * @f1 )) * @fn2( imag( #z ) * imag( #z * @f1 )))
  elseif (@forma==4)
    r2 = cabs( @fn2( real( #z ) * @f1 ) * @fn2( imag( #z ) * @f1 ))
  elseif (@forma==5)
    r2 = cabs( @fn2( real( #z ) * @f1 ) + @fn2( imag( #z ) * @f1 ))
  endif
  #solid = true
  if (@test==0)
    #index = cabs( @fn1( r2 ))
    #solid = false
  elseif (@test==1)
    #index = 0
    if (r2 < |#z|)
      #index = cabs( @fn1( r2 ))
      #solid = false
    endif
  elseif (@test==2)
    #index = 0
    if (r2 < real( #z ))
      #index = cabs( @fn1( r2 ))
      #solid = false
    endif
  elseif (@test==3)
    #index = 0
    if (r2 < imag( #z ))
      #index = cabs( @fn1( r2 ))
      #solid = false
    endif
  elseif (@test==4)
    #index = 0
    if (r2 < dmin)
      #index = cabs( @fn1( r2 ))
      #solid = false
    endif
  elseif (@test==5)
    #index = 0
    if (r2 < dmax)
      #index = cabs( @fn1( r2 ))
    endif
  elseif (@test==6)
    #index = 0
    if (r2 < #numiter)
      #index = cabs( @fn1( r2 ))
    endif
  endif
  if !@usol
    #solid = false
  endif
default:
  title = "Lines"
  param f1
    caption = "Factor"
    default = 1.0
  endparam
  param forma
    default = 0
    caption = "Calculation type"
    enum = "Type 0" "Type 1" "Type 2" "Type 3" "Type 4" "Type 5"
  endparam
  param test
    default = 0
    caption = "Test type"
    enum = "No Test" "|z|" "real(z)" "imag(z)" "|z| min" "|z| max" "Iteration"
  endparam
  param usol
    caption = "Use solid color"
    default = false
  endparam
  func fn1
    default = log()
    caption = "Potential"
  endfunc
  func fn2
    default = atan()
    caption = "Evaluation"
  endfunc
}

Mac001 { ; Marcelo Anelli
init:
  complex r1 = (0.0, 0.0)
final:
  r1 = @fn1( real(#z) / imag(#z)) + flip ( @fn2( imag(#z) / real( #z)) )
  #index = @factor * cabs( r1 )
default:
  title = "Mac001"
  param factor
    default = 1.0
    caption = "Factor of coloring"
  endparam
  func fn1
    default = atan()
    caption = "First term"
  endfunc
  func fn2
    default = atan()
    caption = "Second term"
  endfunc
}

Mac002 { ; Marcelo Anelli
init:
  complex r1 = (0.0, 0.0)
final:
  r1 = @fn1( real(#z) - imag(#z)) * flip ( @fn2( imag(#z) + real( #z)) )
  #index = @factor * cabs( r1 )
default:
  title = "Mac002"
  param factor
    default = 1.0
    caption = "Factor of coloring"
  endparam
  func fn1
    default = atan()
    caption = "First term"
  endfunc
  func fn2
    default = atan()
    caption = "Second term"
  endfunc
}

Mac003 { ; Marcelo Anelli
init:
  float r2 = 0.0
  float gc = 0.0
  complex z1 = (0.0, 0.0)
  complex z_values[#maxiter + 1]
  z_values[0] = #z
  int i = 0
loop:
  i = i+1
  z_values[i] = #z  
final:
  int iter = 1
  while iter <= #numiter
    r2 = r2 + cabs(z_values[#numiter])
    z1 = z1 + z_values[#numiter]
    iter = iter + 1
  endwhile
  if (@formula==0)
    #index = @fac1 * r2
  elseif (@formula==1)
    gc = cabs( log( cabs( z1 ))) / ( 2 ^ #numiter )
    #index = @fac1 * cabs(( -1 * log( gc ) / log( 2.0 ) ))
  endif
default:
  title = "Mac003"
  param fac1
    default = 0.05
    caption = "Factor of coloring"
  endparam
  param formula
    default = 0
    caption = "Coloring method"
    enum = "Normal" "Potential"
  endparam
}

Mac004 { ; Marcelo Anelli
init:
  float rx = 0.0
final:
  if (@formula == 0)
    rx = |@fn1( #z - @appli )|
    #index = @fac1 * rx
  elseif (@formula == 1)
    rx = |@fn1( #pixel - @appli )|
    #index = @fac1 * rx
  elseif (@formula == 2)
    rx = |@fn1( real(#z) - @appli )|
    #index = @fac1 * rx
  elseif (@formula == 3)
    rx = |@fn1( imag(#z) - @appli )|
    #index = @fac1 * rx
  endif
default:
  title = "Mac004"
  param fac1
    default = 0.05
    caption = "Factor of coloring"
  endparam
  param formula
    default = 0
    caption = "Coloring method"
    enum = "|z|" "|pixel|" "real(z)" "imag(z)"
  endparam
  param appli
    default = (0.0, 0.0)
    caption = "Point"
  endparam
  func fn1
    caption = "Transformation"
    default = ident()
  endfunc
}

Mac005 { ; Marcelo Anelli
init:
  float rx = 0.0
  float ry = 0.0
  float dx = 0.0
  float dy = 0.0
loop:
  if (@forma == 0 )
    rx = real( #z )
    ry = imag( #z )
  elseif (@forma == 1 )
    rx = real( #z ) / imag( #z )
    ry = imag( #z ) / real( #z )
  elseif (@forma == 2 )
    rx = real( #z ) * real( #z ) / imag( #z )
    ry = imag( #z ) * imag( #z ) / real( #z )
  elseif (@forma == 3 )
    rx = real( #z ) / ( imag( #z ) * real( #z ) )
    ry = imag( #z ) / ( imag( #z ) * real( #z ) )
  endif

  if (@calc == 0 )
    if (rx < @eps)
      dx = dx * @fac1 + ( 1.0 - rx / @eps )
    endif
    if (ry < @eps)
      dy = dy * @fac1 + ( 1.0 - ry / @eps )
    endif
  elseif (@calc == 1 )
    dx = @fac1 * ( 1.0 - rx / @eps )
    dy = @fac1 * ( 1.0 - ry / @eps )
  elseif (@calc == 2 )
    if (rx < @eps)
      dx = dx * @fac1 + ( 1.0 - rx / @eps ) * ( 1.0 - rx / @eps )
    endif
    if (ry < @eps)
      dy = dy * @fac1 + ( 1.0 - ry / @eps ) * ( 1.0 - ry / @eps )
    endif
  endif
final:
  #index = ( dx + dy ) / 2
default:
  title = "Mac005"
  param forma
    default = 0
    enum = "Form 1" "Form 2" "Form 3" "Form 4"
  endparam
  param calc
    default = 0
    enum = "Sum" "Last value" "Squared sum"
  endparam
  param fac1
    default = 5.0
    caption = "Factor of coloring"
  endparam
  param eps
    default = 10.0
    caption = "Thereshold"
  endparam
}

decomp(OUTSIDE) {
; Reproduces the decomp option in Fractint. Use the Smooth Coloring 
; parameter to turn true-color output on and off.
;
; Modified by Marcelo Anelli. 18/4
final:
  float lf = 0
  float mlf = 0
  float iter = 0
  float angle = atan2(#z)
  int   colors = 0
  
  ; normalize angle to the range 0..2*pi
  if angle < 0
    if (@fix == 0 )
      angle = angle + 2 * #pi
    elseif (@fix == 1 )
      angle = abs(angle)
    endif
  endif
  
  ; calculate number of colors
  ; colors = round(2 ^ (@decomp + 1)) Modified
  colors = @decomp
  ;if colors < 256
  ;  iter = 1
  ;endif
  
  if @smooth
    iter = iter + (angle * (colors - iter)) / (2 * #pi)
  else
    iter = iter + trunc((angle * colors) / (2 * #pi))
  endif
  
  if (@logmap != 0) && (iter > #maxiter)
    iter = #maxiter
  endif    

  if @logmap > 0
    if @logmap > 1
      lf = @logmap
    else
      lf = 0
    endif
      
    if lf >= #maxiter
      lf = #maxiter - 1
    endif
    
    if lf > 0
      mlf = 254 / log(#maxiter - lf)
    else
      mlf = 255 / log(#maxiter)
    endif
      
    if iter <= lf 
      iter = 1
    elseif (iter - lf) / log(iter - lf) <= mlf
      if lf > 0
        iter = iter - lf + 1
      else
        iter = iter - lf
      endif
    else
      iter = 1 + mlf * log(iter - lf)
    endif
    
  elseif @logmap == -1
    if iter == 0
      iter = 1
    else
      iter = 1 + (255 / log(150)) * log(iter)
    endif
    
  elseif @logmap < -1
    lf = -@logmap
    
    if lf >= #maxiter
      lf = #maxiter - 1
    endif
     
    mlf = 254 / sqrt(#maxiter - lf)
      
    if iter <= lf
      iter = 1
    elseif (iter - lf) <= mlf*mlf
      iter = iter - lf + 1
    else
      iter = 1 + mlf * sqrt(iter - lf)
    endif    
    
  endif

  #index = (iter % 256) / 256 - 0.001

default:
  title = "Decomposition"
  
  param decomp
    caption = "Decomposition"
    hint = "This is the Decomp Option parameter in Fractint in numeric value. Fractint use 2, 4, 8, ,,, 256"
    default = 256
  endparam
  
  param logmap
    caption = "Log Palette"
    hint = "This is exactly the same as the Log Palette value \
            in Fractint. 0=no, 1=yes, -1=old, +n=cmprsd, -n=sqrt."
    default = 0
  endparam

  param smooth
    caption = "Smooth coloring"
    hint = "This defines whether or not the image will be colored smoothly. \
            Enable it to get smooth true-color decomposition; disable it \
            to restrict the number of colors to the decomposition value, \
            just like in Fractint."
    default = true
  endparam

  param fix
    caption = "Fix negative angle"
    default = 0
    enum = "Normalization" "Absolute value"
  endparam
}

Mac007 { ; Marcelo Anelli
; written by Mac, April 26
; inspired on ZtoIndex by Paul Carlson
final:
  float valor = @w0 * cabs(@fn1(#numiter)) + @w1 * cabs(@fn2(real(#z))) + @w2 * cabs(@fn3(imag(#z)))
  if (@forma == 0)
    #index = valor
  elseif (@forma==1)
    #index = valor - round(valor)
  elseif (@forma==2)
    #index = ceil(valor) - valor
  elseif (@forma==3)
    #index = sin(valor)
  elseif (@forma==4)
    #index = cos(valor)
  elseif (@forma==5)
    #index = 1/valor
  elseif (@forma==6)
    valor = 1 / valor
    #index = valor - round(valor)
  elseif (@forma==7)
    valor = 1 / valor
    #index = ceil(valor) - valor
  endif
default:
  title = "Mac007"
  param forma
    default = 0
    enum = "normal" "rounded" "ceiling" "sin" "cos" "recip" "recip rounded" \
       "recip ceiling"
  endparam
  param w0
    default = 0.01
    caption = "Weight iteration"
  endparam
  param w1
    default = 0.01
    caption = "Weight real part"
  endparam
  param w2
    default = 0.01
    caption = "Weight imaginary part"
  endparam
  func fn1
    default = ident()
    caption = "Iteration function"
  endfunc
  func fn2
    default = ident()
    caption = "Real function"
  endfunc
  func fn3
    default = ident()
    caption = "Imaginary function"
  endfunc
}

Mac008 { ; Marcelo Anelli
; written by Mac, May 2
; Inspired on little modifications on Bubble Mandel by Paul Carlson
init:
  float factor = 1.0 / @radio
  float minimo = 1e20
  float maximo = -1e20
  float average = 0.0
  float count = 0.0
  float temp = 0.0
loop:
  temp = cabs( #z )
  average = average + temp
  count = count + 1
  if (temp < minimo)
    minimo = temp
  endif
  if (temp > maximo)
    maximo = temp
  endif
final:
  average = average / count
  if (@forma == 0)
    if (minimo < @radio)
      #index = cabs(@fn1(factor * minimo))
    else
    if (@render == 0)
        #index = 1.0
    else
      #index = 0.0
    endif
    endif
  elseif (@forma == 1)
    if (minimo < @radio)
      #index = cabs(@fn1(factor * maximo))
    else
    if (@render == 0)
        #index = 1.0
    else
      #index = 0.0
    endif
    endif
  elseif (@forma == 2)
    if (minimo < @radio)
      #index = cabs(@fn1(factor * average))
    else
    if (@render == 0)
        #index = 1.0
    else
      #index = 0.0
    endif
    endif
  endif
default:
  title = "Mac008"
  param radio
    default = 2.0
  caption = "Bubble radius"
  endparam
  param forma
    caption = "Form of calculation"
  enum = "Min" "Max" "Average"
  default = 0
  endparam
  param render
    caption = "Start/End"
    default = 0
    enum = "Normal" "Inverted"
  endparam
  func fn1
    caption = "Transformation function"
  default = ident()
  endfunc
}

Mac009 { ; Marcelo Anelli
; April 3, 1999
; based on 3DStalks_Pokorny Copyright (c) Paul W. Carlson, 1998
init:
  float indice = 0.0
  float factor = (@colors - 1) / @width
  float min_dist = 0.0
  float iter = 0.0
  float rango = 0
  float mxre = -1e20
  float mxim = -1e20
  float mnre = 1e20
  float mnim = 1e20
loop:
  if (real(#z) < mnre )
    mnre = real(#z)
  endif
  if (imag(#z) < mnim )
    mnim = imag(#z)
  endif
  if (real(#z) > mxre )
    mxre = real(#z)
  endif
  if (imag(#z) > mxim )
    mxim = imag(#z)
  endif
  if (@forma == 0 )
    if (abs(real(#z)) <= abs(imag(#z)))
        min_dist = abs(real(#z))
    else
        min_dist = abs(imag(#z))
    endif
    if (min_dist < @width && iter > 0)
        indice = factor * min_dist + rango * @colors + 1
    endif
  elseif (@forma == 1 )
    if (abs(imag(#z)) <= abs(real(#z)))
        min_dist = abs(real(#z))
    else
        min_dist = abs(imag(#z))
    endif
    if (min_dist < @width && iter > 0)
        indice = factor * min_dist + rango * @colors + 1
    endif
  elseif (@forma == 2 )
    if (abs(mnre) <= abs(mnim))
        min_dist = abs(mnre)
    else
        min_dist = abs(mnim)
    endif
    if (min_dist < @width && iter > 0)
        indice = factor * min_dist + rango * @colors + 1
    endif
  elseif (@forma == 3 )
    if (abs(mxre) <= abs(mxim))
        min_dist = abs(mxre)
    else
        min_dist = abs(mxim)
    endif
    if (min_dist < @width && iter > 0)
        indice = factor * min_dist + rango * @colors + 1
    endif
  endif
  rango = rango + @boost
  if (rango == @range)
      rango = 0
  endif
  iter = iter + 1
  indice = indice - iter
final:
  #index = indice / 256.0
default:
  title = "Mac009"
  param width
    default = 3.0
    caption = "Stalks width"
  endparam
  param colors
    default = 128.0
    caption = "Colors range"
  endparam
  param range
    default = 1.0
    caption = "Colors in each range"
  endparam
  param forma
    default = 0
    enum = "Normal a" "Reversed a" "Normal b" "Reversed b"
  endparam
  param boost
    caption = "Range color increments"
    default = 1.0
  endparam
}

Mac010 { ; Marcelo Anelli
; May 16, 1999
; based on Celtic_Julia Copyright (c) Paul W. Carlson, 1998
init:
  float r1 = 0.0
  float ri = 0.0
  float rr = 0.0
  int iter = 0
  float index_fac = ( @colors - 1 ) / @width
  float rango = @range
  float indice = @start
loop:
  rr = real( #z )
  ri = imag( #z )
  if ( rr > ri )
    r1 = ri
  else
    r1 = rr
  endif
  iter = iter + 1
  if ( r1 < @width && iter > @skip )
    if ( @forma== 0 )
      indice = index_fac * r1 + rango * @colors
elseif ( @forma == 1 )
      indice = index_fac * rango + r1 * @colors
elseif ( @forma == 2 )
      indice = ( rango + r1 ) * ( @colors + index_fac )
elseif ( @forma == 3 )
      indice = cabs(@fn1( index_fac * r1 )) + rango * @colors
endif
  endif
  rango = rango + @boost
  if (rango == @range)
      rango = 0
  endif
final:
  #index = indice * @range / @colors
default:
  title = "Mac010"
  param width
    default = 3.0
    caption = "Stalks width"
  endparam
  param skip
    default = 1
caption = "Iteration to skip"
  endparam
  param colors
    default = 128.0
    caption = "Colors range"
  endparam
  param range
    default = 1.0
    caption = "Colors in each range"
  endparam
  param forma
    default = 0
    enum = "Form a" "Form b" "Form c" "Form a with function"
  endparam
  param boost
    caption = "Range color increments"
    default = 1.0
  endparam
  param start
    default = 0.0
caption = "Start color"
  endparam
  func fn1
    default = ident()
caption = "Transference function"
  endfunc
}

Mac011 { ; Marcelo Anelli
; May 21, 1999
; based on R4_Pokorny_Julia Copyright (c) Paul W. Carlson
init:
  float itera = 0
  complex k = (0.5,0.5)
  float dist = 0.0
  float factor = (@range - 1) / @size
  float indice = 0.0
  float actual = 0.0
loop:
  if (itera > @skip)
    dist = abs(|#z - k| - 0.1)
    if (dist < @size)
      if ( @forma== 0 )
        indice = factor * dist + actual * @colors
  elseif ( @forma == 1 )
        indice = factor * actual + dist * @colors
    elseif ( @forma == 2 )
        indice = ( actual + dist ) * ( @colors + factor )
  elseif ( @forma == 3 )
        indice = cabs(@fn1( factor * dist )) + actual * @colors
  endif
    elseif (itera == #maxiter - 2)
      indice = 0.98
    endif
  endif
  actual = actual + @boost
  if (actual > @range - 0.5)
        actual = 0
  endif
  itera = itera + 1
final:
  #index = indice * @range / @colors
default:
  title = "Mac011"
  param skip
    default = 1
caption = "Iteration to skip"
  endparam
  param size
    default = 0.2
caption = "Ring size"
  endparam
  param colors
    default = 128.0
    caption = "Colors range"
  endparam
  param range
    default = 10.0
    caption = "Colors in each range"
  endparam
  param boost
    caption = "Range color increments"
    default = 1.0
  endparam
  param forma
    default = 0
    enum = "Form a" "Form b" "Form c" "Form a with function"
  endparam
  func fn1
    default = ident()
caption = "Transference function"
  endfunc
}

Mac012 { ; Marcelo Anelli
; May 23, 1999
; based on MyEqn_Func_Julia Copyright (c) Paul W. Carlson
init:
  float itera = 0
  float dist = 1e20
  float factor = (@range - 1) / @size
  float indice = 0.0
  float actual = 0.0
  complex a = (0.0, 0.0)
loop:
  a = @multiplier * atan(imag(#z) / real(#z))
  if ( @forma== 0 )
    a = a * a + @c
  elseif ( @forma == 1 )
    a = a * a * a + @c
  elseif ( @forma == 2 )
    a = exp(a) + @c
  elseif ( @forma == 3 )
    a = a + @c
  endif
  a = fn1(1 - a) / a
  dist = abs(|#z| - |a|)
  if (dist < @size && itera > @skip)
        indice = factor * dist + actual * @colors
  endif
  actual = actual + @boost
  if (actual > @range - 0.5)
    actual = 0
  endif
  itera = itera + 1
final:
  #index = indice * @range / @colors
default:
  title = "Mac012"
  param skip
    default = 1
caption = "Iteration to skip"
  endparam
  param c
    caption = "Julia Coordinates"
    default = (0.0 , 0.0)
  endparam
  param size
    default = 0.2
caption = "Ring size"
  endparam
  param colors
    default = 128.0
    caption = "Colors range"
  endparam
  param range
    default = 10.0
    caption = "Colors in each range"
  endparam
  param boost
    caption = "Range color increments"
    default = 1.0
  endparam
  param multiplier
    default = 1.0
caption = "Angle multiplier"
  endparam
  param forma
    default = 0
    enum = "Original (sqr)" "Cubic" "Exponential" "no power"
  endparam
  func fn1
    default = ident()
caption = "Calculation function"
  endfunc
}

Mac013 { ; Marcelo Anelli
; May 27, 1999
; based on Petals_Series_Mset Copyright (c) Paul W. Carlson
; modified Sep 3, 2002, adding more parameters
init:
  bool done = FALSE
  float itera = 0
  float d = 1e20
  float indice = 0.0
  float actual = 0.0
  float r = @Radius
  float ro = r + r * @CircleOff
  float r2 = r * r
  float f = 1 - 2 * @CircleOff - @CircleOff * @CircleOff
  float k = @CircleOff * r + r * sqrt(f)  
  float plsqd = 2 * r2 * f        
  float factor = @range / plsqd
loop:
  complex w2 = @Cua2Fac * @fn2(#z * #z)
  complex w4 = @Cua4Fac * @fn2(w2 * w2)
  complex w8  = @Cua8Fac * @fn2(w4 * w4)
  complex w12 = @Cua12Fac * @fn2(w4 * w8)
  complex w16 = @Cua16Fac * @fn2(w4 * w12)
  complex w = @factor * ( w2 - w4 - w8 - w12 - w16 )
  if (itera > @skip)
    float wr = real(w)
    float wi = imag(w)
    bool c1 = (((wr-ro) * (wr - ro) + wi * wi) < r2)
    bool c2 = ((wr * wr + (wi + ro) * (wi + ro)) < r2)
    bool c3 = (((wr + ro) * (wr + ro) + wi * wi) < r2)
    bool c4 = ((wr * wr + (wi-ro) * (wi-ro)) < r2)
if (@l || !done)
      if (c1 && c4)
        done = TRUE
        float d = (wr - k) * (wr - k) + (wi - k) * (wi - k)
      elseif (c1 && c2)
        done = TRUE
        d = ( wr - k) * ( wr - k) + (wi + k) * (wi + k)
      elseif (c2 && c3)
        done = TRUE
        d = (wr + k) * (wr + k) + (wi + k) * (wi + k)
      elseif (c3 && c4)
        done = TRUE
        d = (wr + k) * (wr + k) + (wi - k) * (wi - k)
      endif
endif
  endif
  if (done)
    d = cabs(@fn1(d))
    indice = factor * d + @colors * actual
  elseif (itera == #maxiter - 2)
    done = TRUE
    indice = 251
  endif
  actual = actual + @boost
  if (actual >= @range)
    actual = 0
  endif
  itera = itera + 1
final:
  #index = indice * @range / @colors
default:
  title = "Mac013"
  param skip
    default = 1
caption = "Iteration to skip"
  endparam
  param l
    caption = "Stop calculation"
    default = true
  endparam
  param factor
    caption = "Initial factor"
default = 1.0
  endparam
  param colors
    default = 128.0
    caption = "Colors range"
  endparam
  param range
    default = 10.0
    caption = "Colors in each range"
  endparam
  param boost
    caption = "Range color increments"
    default = 1.0
  endparam
  param Radius
    caption = "Circles radius"
    default = 0.18
    hint = "Controls petal width."
  endparam
  param CircleOff
    caption = "Circles offset"
    default = 0.05
    hint = "Controls petals offset."
  endparam
  param Cua2Fac
    caption = "Cuadratic weight"
    default = 1.0
    hint = "Cuadratic weight."
  endparam
  param Cua4Fac
    caption = "Exponentiation weight"
    default = 0.01
    hint = "Power 4 weight."
  endparam
  param Cua8Fac
    caption = "Exponentiation weight"
    default = 1.0
    hint = "Power 8 weight."
  endparam
  param Cua12Fac
    caption = "Exponentiation weight"
    default = 1.0
    hint = "Power 12 weight."
  endparam
  param Cua16Fac
    caption = "Exponentiation weight"
    default = 1.0
    hint = "Power 16 weight."
  endparam
  func fn1
    default = ident()
caption = "Calculation function"
  endfunc
  func fn2
    default = ident()
caption = "Exponentiation function"
  endfunc
}

Mac014 { ; Marcelo Anelli
; May 28, 1999
init:
  int iter = 0
  complex v = (0.0, 0.0)
  complex z_values[#maxiter + 1]
  z_values[0] = #z
  int i = 0
loop:
  i = i+1
  z_values[i] = #z  
final:
  iter = #numiter - @skip
  if (@forma==0)
    if (iter > 0 )
      v = #z - z_values[#numiter]
    else
      v = #z
    endif
  elseif (@forma==1)
    if (iter > 0 )
      v = #z + z_values[#numiter]
    else
      v = #z
    endif
  elseif (@forma==2)
    if (iter > 0 )
      v = #z * #z + z_values[#numiter] * z_values[#numiter]
    else
      v = #z * #z
    endif
  elseif (@forma==3)
    if (iter > 0 )
      v = #z * #z - z_values[#numiter] * z_values[#numiter]
    else
      v = #z * #z
    endif
  elseif (@forma==4)
    if (iter > 0 )
      v = #z * #z + 2 * #z * z_values[#numiter] - z_values[#numiter] * z_values[#numiter]
    else
      v = #z * #z
    endif
  endif
  v = (@fn1(v) - @min) / (@max - @min)
  #index = cabs(v)
default:
  title = "Mac014"
  param skip
    default = 1
caption = "Iteration to compare"
  endparam
  param max
    caption = "Maximal value"
    default = (20.0, 20.0)
  endparam
  param min
    default = (0.0, 0.0)
    caption = "Minimal value"
  endparam
  param forma
    default = 0
caption = "Form of computing"
enum = "Difference" "Sum" "Squared 1" "Squared 2" "Squared 3"
  endparam
  func fn1
    default = ident()
caption = "Calculation function"
  endfunc
}

Mac015 { ; Marcelo Anelli
; Jun 6, 1999
init:
  int iter = 0
  complex v = #pixel
  complex z_values[#maxiter + 1]
  z_values[0] = #z
  int i = 0
loop:
  if (@itera==0)
    if (iter > 0 )
      v = v - #z
    endif
  elseif (@itera==1)
    if (iter > 0 )
      v = v + #z
    endif
  elseif (@itera==2)
    if (iter > 0 )
      v = v * v + #z * #z
    else
      v = v * v
    endif
  elseif (@itera==3)
    if (iter > 0 )
      v = v * v - #z * #z
    else
      v = v * v
    endif
  elseif (@itera==4)
    if (iter > 0 )
      v = v * v + 2 * v * #z - #z * #z
    else
      v = v * v
    endif
  endif
  i = i+1
  z_values[i] = #z  
final:
  iter = #numiter - @skip
  if (@forma==0)
    if (iter > 0 )
      v = v - z_values[#numiter]
    endif
  elseif (@forma==1)
    if (iter > 0 )
      v = v + z_values[#numiter]
    endif
  elseif (@forma==2)
    if (iter > 0 )
      v = v * v + z_values[#numiter] * z_values[#numiter]
    else
      v = v * v
    endif
  elseif (@forma==3)
    if (iter > 0 )
      v = v * v - z_values[#numiter] * z_values[#numiter]
    else
      v = v * v
    endif
  elseif (@forma==4)
    if (iter > 0 )
      v = v * v + 2 * v * z_values[#numiter] - z_values[#numiter] * z_values[#numiter]
    else
      v = v * v
    endif
  endif
  v = (@fn1(v) - @min) / (@max - @min)
  #index = cabs(v)
default:
  title = "Mac015"
  param skip
    default = 1
caption = "Iteration to use"
  endparam
  param max
    caption = "Maximal value"
    default = (20.0, 20.0)
  endparam
  param min
    default = (0.0, 0.0)
    caption = "Minimal value"
  endparam
  param itera
    default = 0
caption = "Form of iterating"
enum = "Difference" "Sum" "Squared 1" "Squared 2" "Squared 3"
  endparam
  param forma
    default = 0
caption = "Form of computing"
enum = "Difference" "Sum" "Squared 1" "Squared 2" "Squared 3"
  endparam
  func fn1
    default = ident()
caption = "Calculation function"
  endfunc
}

Mac006 {
 ; Marcelo Anelli
init:
  float rx = 0.0
  float ry = 0.0
  float rz = 0.0
  float dx = 0.0
  float dy = 0.0
loop:
  if (@forma == 0)
    rz = real( #z ) * real( #z ) * real( #z ) + imag( #z ) * imag( #z ) * imag( #z )
  elseif (@forma == 1)
    rz = real( #z ) * real( #z ) + imag( #z ) * imag( #z )
  elseif (@forma == 2)
    rz = real( #z ) + imag( #z )
  elseif (@forma == 3)
    rz = real( #z ) * real( #z ) * real( #z ) * real( #z ) + imag( #z ) * imag( #z ) * imag( #z ) * imag( #z )
  elseif (@forma == 4)
    rz = real( #z ) * real( #z ) * real( #z ) / imag( #z ) + imag( #z ) * imag( #z ) * imag( #z ) / real( #z )
  elseif (@forma == 5)
    rz = real( #z ) * real( #z ) / imag( #z ) + imag( #z ) * imag( #z ) / real( #z )
  endif
  rx = rz + real(@fn1( #z ))
  ry = rz + imag(@fn2( #z ))

  if (rx < @eps)
    dx = dx * @fac1 + ( 1.0 - rx / @eps )
  endif
  if (ry < @eps)
    dy = dy * @fac1 + ( 1.0 - ry / @eps )
  endif
final:
  #index = ( dx + dy ) / 2
default:
  title = "Mac006"
  param fac1
    default = 5.0
    caption = "Factor of coloring"
  endparam
  param forma
    default = 0
    enum = "Form a" "Form b" "Form c" "Form d" "Form e" "Form f"
  endparam
  param eps
    default = 10.0
    caption = "Thereshold"
  endparam
  func fn1
    caption = "Transformation real"
    default = ident()
  endfunc
  func fn2
    caption = "Transformation imag"
    default = ident()
  endfunc
}