JLB_TrapShapeGIPlus

An extension of the Gaussian Integer shape in Standard.ulb, and to the G. I. colorings in Standard.ucl and lkm.ucl.

The original version uses a square grid of points covering the complex plane. This version generalizes the grid to points of the form n1*v1 + n2*v2, where the complex numbers v1 and v2 are specified by the user, and n1 and n2 are integers. Two special cases are a square grid, as in the original, and a triangular grid. Two added normalization factors are 1/pixel and 1/f(z) Code adapted from Standard.ulb

 class JLB_TrapShapeGIPlus(common.ulb:TrapShape) {
   ; An extension of the Gaussian Integer shape in Standard.ulb,
   ; and to the G. I. colorings in Standard.ucl and lkm.ucl.<p>
   ;
   ; The original version uses a square grid of points covering
   ; the complex plane. This version generalizes the grid to points
   ; of the form n1*v1 + n2*v2, where the complex numbers v1 and v2
   ; are specified by the user, and n1 and n2 are integers.
   ;
   ; Two special cases are a square grid, as in the original, and
   ; a triangular grid.
   ;
   ; Two added normalization factors are 1/pixel and 1/f(z)
   ;
   ; Code adapted from Standard.ulb
 
 public:
 
   func JLB_TrapShapeGIPlus(Generic pparent)
     TrapShape.TrapShape(pparent)
 
     if (@gridtype == "square")
       a1 = 1
       b1 = 0
       a2 = 0
       b2 = 1
       det = 1
     elseif (@gridtype == "triangular")
       a1 = 1
       b1 = 0
       a2 = 0.5                  ; = cos(60 degrees)
       b2 = sqrt(3.0)/2          ; = sin(60 degrees)
       det = b2
     else;if(@gridtype == "custom")
       a1 = @r1*cos(@ang1*#pi/180)
       b1 = @r1*sin(@ang1*#pi/180)
       float ang2 = @ang1 + @delta
       a2 = @r2*cos(ang2*#pi/180)
       b2 = @r2*sin(ang2*#pi/180)
       det = a1*b2-a2*b1
     endif
     ; The basis functions for the grid
     v1 = a1 + flip(b1)
     v2 = a2 + flip(b2)
   endfunc
 
   func Init(complex pz)
     if (@norm == "none")
       fNormFactor = 1
     elseif (@norm == "pixel")
       fNormFactor = #pixel
     elseif (@norm == "factor")
       fNormFactor = @fac
     elseif (@norm == "f(z)")
       fNormFactor = @normfunc(pz)
     elseif (@norm == "1/pixel")
       fNormFactor = 1/#pixel
     elseif (@norm == "factor")
       fNormFactor = @fac
     else;if (@norm == "f(z)")
       fNormFactor = 1/@normfunc(pz)
     endif
   endfunc
 
   float func Iterate(complex pz)
     pz = pz / fNormFactor
     ; Find c1 and c2 so that pz = c1*v1 + c2*v2.
     ; This is unique if det != 0, impossible if det = 0.
     float x = real(pz)
     float y = imag(pz)
     float c1 =  (x*b2-y*a2)/det
     float c2 = -(x*b1-y*a1)/det
     complex temp
     if @inttype == "round(z)"
       temp = round(c1)*v1 + round(c2)*v2
     elseif @inttype == "trunc(z)"
       temp = trunc(c1)*v1 + trunc(c2)*v2
     elseif @inttype == "floor(z)"
       temp = floor(c1)*v1 + floor(c2)*v2
     else;if @inttype == "ceil(z)"
       temp = ceil(c1)*v1 + ceil(c2)*v2
     endif
     return cabs(pz - temp * fNormFactor)
   endfunc
 
 private:
   complex fNormFactor
   complex v1
   complex v2
 
   float a1
   float b1
   float a2
   float b2
   float det
 
 default:
   title = "G.I. Plus"
   param gridtype
     caption = "Grid Type"
     enum = "square" "triangular" "custom"
     default = 0
     hint = "Selects grid type"
   endparam
   float param r1
     caption = "r1"
     default = 1.0
     min = 0
     hint = "Polar coordinates for v1 are r1 and ang1."
     visible = @gridtype >1
   endparam
   float param ang1
     caption = "angle 1"
     default = 0.0
     hint = "degrees"
     visible = @gridtype >1
   endparam
   float param r2
     caption = "r2"
     default = 1.0
     min = 0
     hint = "Polar coordinates for v2 are r2 and ang2, where \
       ang2 = ang1 + delta."
     visible = @gridtype >1
   endparam
   float param delta
     caption = "delta"
     default = 90
     min = 1
     max = 179
     hint = "(degrees) 1 <= delta <= 179"
     visible = @gridtype >1
   endparam
   param inttype
     caption="Integer Type"
     default=0
     enum="round(z)" "trunc(z)" "floor(z)" "ceil(z)"
     hint="Selects between four ways of reducing the orbit value z to an \
           integer. Each produces different effects."
   endparam
   param norm
     caption="Normalization"
     default=0
     enum="none" "pixel" "factor" "f(z)" "1/pixel" "1/f(z)"
     hint="Selects an optional normalization to be applied."
   endparam
   param fac
     caption=" Factor"
     default=(2.0,1.0)
     visible = @norm == "factor"
     hint="Specifies the normalization factor to be used if Normalization is \
           'factor'. Large factors give less-busy coloring."
   endparam
   func normfunc
     caption=" Function"
     default=ident()
     hint="Selects function to be used if Normalization is 'f(z)' or '1/f(z)'."
     visible = (@norm == "f(z)") ||(@norm == "1/f(z)")
   endfunc
 }

Method Summary
`void`	`Init(complex pz)` call this before each sequence of values to be trapped
`float`	`Iterate(complex pz)` call this for each iteration being trapped

Constructor Summary
`JLB_TrapShapeGIPlus()`
`JLB_TrapShapeGIPlus(Generic pparent)`

jlb Class JLB_TrapShapeGIPlus

JLB_TrapShapeGIPlus

JLB_TrapShapeGIPlus

Init

Iterate

jlb
Class JLB_TrapShapeGIPlus