3DStalks_Pokorny {; Copyright (c) Paul W. Carlson, 1998 init: w = #pixel z = bout = iter = range_num = 0 index_factor = (@ColorsInRange - 1) / @StalkWidth loop: w = 1 / (w * w + @C) IF (abs(real(w)) <= abs(imag(w))) min_dist = abs(real(w)) ELSE min_dist = abs(imag(w)) ENDIF IF (min_dist < @StalkWidth && iter > 0) z = index_factor * min_dist + range_num * @ColorsInRange + 1 bout = 1 ENDIF range_num = range_num + 1 IF (range_num == @NumberRanges) range_num = 0 ENDIF iter = iter + 1 z = z - iter bailout: bout == 0 && |w| < @Bailout default: title = "3D Stalks Pokorny" param C caption = "Julia Set Coordinates" default = (-1.3, 0.1) endparam param StalkWidth caption = "Stalk Width" default = 1.0 endparam param Bailout caption = "Bailout Value" default = 1000 endparam param NumberRanges caption = "Number of Ranges" default = 2 endparam param ColorsInRange caption = "Colors in Range" default = 100 endparam } TbNewtMset1 { ; Paul Carlson init: bool first = TRUE bool done = FALSE float Phi = #pi * 0.125 float Rc = real(@R) float Rm = Rc/sin(Phi); float Py = Rm*sin(Phi+Phi) float Px = Rm*cos(Phi+Phi) float RcSqd = Rc*Rc int iter = 0 complex C = #pixel W = sqrt((1 - C)/6) #Z = (250,0) loop: complex W2 = W * W complex W3 = W * W2 complex W4 = W * W3 complex Err = (W4 + (C-1)*W2 - C)/(4*W3 + 2*(C-1)*W) W = W - Err IF ((abs(cabs(W) - Rm) < Rc) && first == FALSE) float X = real(W) float Y = imag(W) float Xabs = abs(X) float Yabs = abs(Y) float Dsqd0 = Xabs*Xabs+(Yabs-Rm)*(Yabs-Rm) float Dsqd1 = (Xabs-Px)*(Xabs-Px)+(Yabs-Py)*(Yabs-Py) float Dsqd2 = (Xabs-Rm)*(Xabs-Rm)+Yabs*Yabs IF (Dsqd0 < RcSqd) done = TRUE float ZtoPsqd = Dsqd0 IF (Y >0 ) float Circle = 0 ELSE Circle = 4 ENDIF ELSEIF (Dsqd1 < RcSqd) done = TRUE ZtoPsqd = Dsqd1 IF (Y > 0 && X > 0) Circle = 1 ELSEIF (Y < 0 && X > 0) Circle = 3 ELSEIF (Y < 0 && X < 0) Circle = 5 ELSE Circle = 7 ENDIF ELSEIF (Dsqd2 < RcSqd) done = TRUE ZtoPsqd = Dsqd2 IF (X > 0) Circle = 2 ELSE Circle = 6 ENDIF ENDIF ENDIF IF (done == TRUE) float Ratio = sqrt(ZtoPsqd/Rcsqd) #Z = 29.0 * Ratio + Circle * 30.0 ELSEIF (|Err| < 0.000001) done = TRUE IF (iter % 2 == 0) #z = 254 ELSE #z = 253 ENDIF ENDIF first = FALSE iter = iter + 1 bailout: done == FALSE default: title = "Tangent Balls Newton Mset" maxiter = 3000 param R caption = "Circle radius" default = 0.2 hint = "The radius of the trap circles." endparam } RsNewtMset1 { ; Paul Carlson init: bool done = FALSE float HalfT = 0.5 * @T float Phi = #pi * 0.125 float Ro = @Rm + HalfT float Py = @Rm*sin(Phi) float Px = @Rm*cos(Phi) float Dsqd = @Rm*@Rm + Ro*Ro - 2*Ro*Px complex C = #pixel W = sqrt((1 - C)/6) int skip_iters = @skip int iter = 0 #Z = (253,0) loop: complex W2 = W * W complex W3 = W * W2 complex W4 = W * W3 complex Err = (W4 + (C-1)*W2 - C)/(4*W3 + 2*(C-1)*W) W = W - Err IF ((abs(cabs(W) - @Rm) < HalfT) && iter >= skip_iters) done = TRUE float X = real(W) float Y = imag(W) float Xabs = abs(X) float Yabs = abs(Y) IF (Xabs >= Yabs) float WtoPsqd = (Xabs-Px)*(Xabs-Px) + (Yabs-Py)*(Yabs-Py) ELSE WtoPsqd = (Xabs-Py)*(Xabs-Py) + (Yabs-Px)*(Yabs-Px) ENDIF IF (X >= 0 && Y >= 0) IF (Xabs >= Yabs) float Segment = 0 ELSE Segment = 1 ENDIF ELSEIF (X < 0 && Y >= 0) IF (Xabs < Yabs) Segment = 2 ELSE Segment = 3 ENDIF ELSEIF (X < 0 && Y < 0) IF (Xabs >= Yabs) Segment = 4 ELSE Segment = 5 ENDIF ELSE IF (Xabs < Yabs) Segment = 6 ELSE Segment = 7 ENDIF ENDIF float Ratio = sqrt(WtoPsqd/Dsqd) #Z = 29.0 * Ratio + Segment * 30.0 ELSEIF (|Err| < 0.000001) done = TRUE #Z = (252,0) ENDIF iter = iter + 1 bailout: done == FALSE default: title = "Ring Segments Newton Mset" maxiter = 3000 param Rm caption = "Ring radius" default = 1.0 hint = "The radius to the midline of the ring." endparam param T caption = "Ring thickness" default = 0.2 hint = "The thickness of the ring." endparam param skip caption = "Iterations to skip" default = 1 hint = "Iterations to skip." endparam } Four_Julias {; Paul Carlson init: complex c = @JuliaCoords bool first = TRUE bool done = FALSE float range_num = 0 float px = real(#scrnpix) float py = imag(#scrnpix) float hmx = 0.5 * real(#scrnmax) float hmy = 0.5 * imag(#scrnmax) #z = 255 IF ((px < 2) || (px > (real(#scrnmax) - 3)) || \ (py < 2) || (py > (imag(#scrnmax) - 3)) || \ ((px > hmx - 2) && (px < hmx + 1)) || \ ((py > hmy - 2) && (py < hmy + 1))) #z = 252 done = TRUE ENDIF IF (done == FALSE) IF (px < hmx) IF (py > hmy) complex w = 2 * (#pixel + (1,0.75)) float size = 0.04 int quad = 3 ELSE complex prev_w = 2 * (#pixel + (1.0,-0.75)) size = 0.07 quad = 1 ENDIF ELSE IF (py > hmy) w = 2 * (#pixel + (-1,0.75)) size = 0.05 float k = 0.5 + size float j = 0.5 - size quad = 4 ELSE w = 2 * (#pixel + (-1.0,-0.75)) size = 0.01 quad = 2 ENDIF ENDIF float index_factor = 29 / size ENDIF loop: IF (done == FALSE) IF (quad == 1) w = prev_w * prev_w + c float dist = |prev_w| / |w| prev_w = w ELSE w = w * w + c IF (quad == 2) dist = abs(|w|-.25) ELSEIF (quad == 3) IF (abs(real(w)) <= abs(imag(w))) dist = abs(real(w)) ELSE dist = abs(imag(w)) ENDIF ELSEIF (quad == 4) float awr = abs(real(w)) float awi = abs(imag(w)) IF ((awr < k) && (awr > j) && \ (awi < k) && (awi > j)) float awr5 = abs(awr - 0.5) float awi5 = abs(awi - 0.5) IF (awr5 <= awi5) dist = awr5 ELSE dist = awi5 ENDIF ELSE dist = 1.0e30 ENDIF ENDIF ENDIF IF (dist < size && first == FALSE) done = TRUE #z = index_factor * dist + range_num * 30 ENDIF ENDIF range_num = range_num + 1 IF (range_num > 7.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE && |w| < 4 default: title = "Four Julia Sets" maxiter = 5000 param JuliaCoords caption = "Julia Coordinates" default = (0.35408308,0.095460802) hint = "The Julia set coordinates." endparam } MandelBubs1 {; Paul W. Carlson init: bool done = FALSE complex w = (0,0) complex c = #pixel float index_factor = 249.0/@max_min_w float min_w = 1.0e20 #z = 0.0 loop: w = w * w + c float temp = cabs(w) IF (temp < min_w) min_w = temp ENDIF IF (|w| > @max_w) done = TRUE IF (min_w < @max_min_w) #z = index_factor * min_w ELSE #z = 253.0 ENDIF ENDIF bailout: done == FALSE default: title="Mandel Bubbles 1" param max_min_w caption="Bubble radius" default=0.188 endparam param max_w caption="Bailout radius squared" default=16 endparam } Newt_Fang_Mset {; init: bool done = FALSE bool first = TRUE a = fn1(#pixel) am = a - 1 w = sqrt(-am / 6) range_num = 0 index_factor = 20.0 / real(@width) prev_mod2 = |w| #z = 253 loop: k = w * w, q = w * am w = w - (k * k + k * am - a) / (4 * w * k + q + q) angle = atan(imag(w) / real(w)) v = @multiplier * (fn1(angle)^2 + fn2(angle)^2) dist = abs(|w| - |v|) IF (dist < real(@width) && first == FALSE) done = TRUE #z = index_factor * dist + range_num * 30.0 ELSEIF (abs(|w| - prev_mod2) < 0.000001) done = TRUE #z = 252 ENDIF prev_mod2 = |w| range_num = range_num + 1 IF (range_num > 7.5) range_num = 0.0 ENDIF first = FALSE bailout: done == FALSE && |w| < 10000000 default: title = "Newton Function Angle Mset" maxiter = 251 param width caption = "Width Factor" default = 1.0 hint = "Controls element size." endparam param multiplier caption = "Multiplier" default = (1,0) hint = "Equation multiplier." endparam } 3D_Phoenix_Spirals {;Paul W. Carlson init: bool done = FALSE complex prev_w = #pixel complex v = pixel complex c = @JuliaCoords float range_num = 0 float index_factor = 250 / #pi #z = 253 loop: w = prev_w * prev_w - 0.5 * prev_w + c complex b = w * w - 0.5 * v + c v = w w = b IF (w > 1) float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float angle = abs(atan(delta_i / delta_r)) IF (delta_r < 0) angle = #pi - angle ENDIF done = TRUE #z = index_factor * angle + range_num * 125 ENDIF prev_w = w range_num = range_num + 1 IF (range_num > 1.5) range_num = 0 ENDIF bailout: done == FALSE default: title = "Phoenix Julia Sets" maxiter = 321 param JuliaCoords caption = "Julia Coordinates" default = (0.563,0) hint = "The Julia set coordinates." endparam } Mandel_3Way {; Paul Carlson init: bool done = FALSE float r = @rad2 float skipiters = @skip iters = 0 complex w = 0 float range_num = 0 complex c = #pixel float prev_modw2 = 1.0e20 #z = 253 loop: w = w * w + c; IF ((prev_modw2 < r) && (|w| > r) && iters > skipiters) done = TRUE index = 124.0 * (r - prev_modw2) / r #z = index + range_num * 125.0 ENDIF prev_modw2 = |w| range_num = range_num + 1 IF (range_num > 1.5) range_num = 0 ENDIF iters = iters + 1 bailout: done == FALSE && |w| <= r default: title = "3-Way Mandel" maxiter = 2000 param rad2 caption = "Escape radius squared" default = 4 hint = "Escape radius squared." endparam param skip caption = "Iterations to skip" default = 21 hint = "Iterations to skip." endparam } Mod_Phoenix_Q {; Paul Carlson init: bool first = TRUE bool done = FALSE w = #pixel y = #pixel c = @JuliaCoords range_num = 0 ;** The 124 is the number of colors in a range minus one ;** (should be a parameter). index_factor = 124.0 / @width ;** The sky color - used when the point is not trapped. #z = 253 loop: ;** The equations we're iterating. w2 = w * w w = w * w2 - w2 - 0.5 * w + c b = w w = b * b - 0.5 * y + c y = b ;** Get the min. distance from the point to an axis. IF (abs(real(w)) <= abs(imag(w))) min_dist_to_axis = abs(real(w)) ELSE min_dist_to_axis = abs(imag(w)) ENDIF ;** If the min. distance is less than 'width' the point ;** is trapped, set z equal to the index into the colormap. ;** Skip the first iteration. ;** The 125 is the number of colors in a range. IF (min_dist_to_axis < @width && first == FALSE) #z = index_factor * min_dist_to_axis + range_num * 125.0 done = TRUE ENDIF ;** Cycle through the ranges of color. I could have used ;** a MOD function, but I'm translating from my Fractint stuff. ;** Assumes 2 color ranges (should be a parameter). range_num = range_num + 1 IF (range_num > 1.5) range_num = 0.0 ENDIF first = FALSE bailout: done == FALSE && |w| < @MaxZsqd default: title = "Modified Phoenix Quartic" maxiter = 251 param JuliaCoords caption = "Julia Coordinates" default = (-0.55,0) hint = "The Julia set coordinates." endparam param width caption = "Width Factor" default = 0.01 hint = "Controls element size." endparam param MaxZsqd caption = "Maximum |z|" default = 100 hint = "Maximum |z| for bailout." endparam } FlexBalls_Pky {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float r = real(@RadiusWidth) float t = imag(@RadiusWidth) float skip = real(@SkipMaxW) float maxw = imag(@SkipMaxW) float d0 = r + t float d1 = 0.382683432365 * t float d2 = 0.923879532511 * t float dsqd = d0 * d0 + t * t - (d0 + d0) * d2 float iter = 0 #z = 253 loop: w = 1 / (w * w + c) IF ((abs(cabs(w) - r) < t) && iter > skip) done = TRUE float wr = real(w) float wi = imag(w) float awr = abs(wr) float awi = abs(wi) IF (awr >= awi) float dist = (awr - d2) * (awr - d2) + (awi - d1) * (awi - d1) adjust = 1 ELSE dist = (awr - d1) * (awr - d1) + (awi - d2) * (awi - d2) adjust = 0 ENDIF IF (wr >= 0 && wi >= 0) range_num = 1 - adjust ELSEIF (wr < 0 && wi >= 0) range_num = 2 + adjust ELSEIF (wr < 0 && wi < 0) range_num = 5 - adjust ELSE range_num = 6 + adjust ENDIF float ratio = sqrt(dist / dsqd) #z = 29 * ratio + range_num * 30 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < maxw default: title = "Pokorny FlexBalls" maxiter = 251 param JuliaCoords caption = "Julia Coordinates" default = (-0.4089044078,0.500779323281) hint = "The Julia set coordinates." endparam param RadiusWidth caption = "Ring Radius and Width" default = (0.12,0.1) hint = "Ring Radius and Width." endparam param SkipMaxW caption = "Iters to skip and Max |z|" default = (50,1000) hint = "Iters to skip and Max |z|." endparam } Newt1_Stalks_Mset {; Paul Carlson ; Newton's solution of w^4 + (c-1)*w^2 - c = 0 ; Initial value of w is the value for which the ; second derivative equals zero (a critical point): ; F(w) = w^4 + (c-1)*w^2 - c ; F'(w) = 4*w^3 + 2*(c-1)*w ; F''(w) = 12*w^2 + 2*(c-1) which equals zero when ; w = sqrt((1 - c) / 6) init: c = #pixel cm1 = c - 1 tcm1 = cm1 + cm1 w = sqrt((1 - c) / 6) range_num = 0 stalk_width = real(@SizeSkip) skip = imag(@SizeSkip) num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width prev_mod2 = |w| #z = 252 loop: w2 = w * w w = w - (w2 * w2 + cm1 * w2 - c) / (4 * w2 * w + tcm1 * w) IF (abs(real(w)) <= abs(imag(w))) dist = abs(real(w)) ELSE dist = abs(imag(w)) ENDIF IF (dist < stalk_width && iter > imag(p1)) #z = index_factor * dist + range_num * colors_in_range done = TRUE ELSEIF (abs(|w| - prev_mod2) < 0.000001) done = TRUE #z = 252 ENDIF prev_mod2 = |w| range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < @MaxZ default: title = "Newton 1 Stalks" maxiter = 253 param SizeSkip caption = "Size and Skip" default = (0.1,0) hint = "Stalk size and iters to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam param MaxZ caption = "Max. |z| for bailout" default = 1E20 hint = "Max. |z| for bailout." endparam } Log_Series_Mset {; Paul Carlson init: bool done = FALSE float size = real(@width) float range_num = 0 complex c = #pixel complex w = 0 #z = 253 loop: complex prev_w = w complex w2=w*w complex w4=w2*w2 complex w6=w2*w4 complex w8=w4*w4 complex w10=w6*w4 complex w12=w6*w6 ;The series we're iterating w = w2 - w4/2 + w6/3 - w8/4 + w10/5 - w12/6 + c ;If real(w) exceeds the input value, compute the colormap ;index using orbit slope and bail out. IF (abs(real(w)) > size) done = TRUE float angle = abs(atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))) float index = 250.0 * angle / #pi #z = index + range_num * 125.0 + 1.0 ENDIF ;Cycle thru the color ranges range_num = range_num + 1 IF (range_num > 1.5) range_num = 0.0 ENDIF bailout: done == FALSE default: title = "Log Series Mset" maxiter = 1000 param width caption = "Width Factor" default = 2.0 hint = "Controls element size." endparam } RCoshM1 {; Paul Carlson init: bool done = FALSE bool first = TRUE complex w = 0 complex c = #pixel float ring_width = @width float index_factor = 124 / ring_width float iter = 1 #z = 253 loop: w = cosh(w) + c dist = abs(|w|-.25) IF (dist < ring_width && first == FALSE) done = TRUE #z = index_factor * dist + 128.0 ELSEIF |w| >= 1.0e30 #z = iter ENDIF first = FALSE iter = iter + 1 bailout: done == FALSE && |w| < 1.0e30 default: title = "Cosh Rings" maxiter = 1000 param width caption = "Ring Width Factor" default = 2.0 hint = "Controls ring width." endparam } Spir2_Trunc {; Paul Carlson init: bool done = FALSE bool first = TRUE w = #pixel c = @JuliaCoords range_num = 0 stalk_width = real(@WidthMaxW) max_wm = imag(@WidthMaxW) num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width #z = 253 loop: ;The equations we're iterating w = w * w - c wr = real(w) awr = abs(wr) w = w - wr + awr ;The usual stalk stuff... awr = abs(real(w)) awi = abs(imag(w)) IF (awr <= awi) dist = awr ELSE dist = awi ENDIF ; ...but we truncate the stalks when |w| >= max_wm IF (dist < stalk_width && |w| < max_wm && first == FALSE) #z = index_factor * dist + range_num * colors_in_range done = TRUE ENDIF ;Cycle thru the color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE && |w| < 4 default: title = "Spiral 2 Truncated" maxiter = 5000 param JuliaCoords caption = "Julia Coordinates" default = (-0.378083004695,0.227300793319) hint = "The Julia set coordinates." endparam param WidthMaxW caption = "Stalk Width and Max W" default = (0.03,0.1) hint = "Stalk Width and Max W." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Spir_Stalks {; Paul Carlson init: bool done = FALSE bool first = TRUE w = #pixel c = @JuliaCoords range_num = 0 stalk_width = real(@WidthMaxW) max_wm = imag(@WidthMaxW) num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width ;The color at maximum iterations #z = 252 loop: ;The equations we're iterating w = w * w - c wr = real(w) awr = abs(wr) w = w - wr + awr ;The usual stalk stuff... awr = abs(real(w)) awi = abs(imag(w)) IF (awr <= awi) dist = awr ELSE dist = awi ENDIF IF (dist < stalk_width && first == FALSE) #z = index_factor * dist + range_num * colors_in_range done = TRUE ELSEIF (|w| >= max_wm) ;The color at early bailout, point untrapped #z = 253 done = TRUE ENDIF ;Cycle thru the color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE default: title = "Spiral 3D Stalks" maxiter = 5000 param JuliaCoords caption = "Julia Coordinates" default = (-0.362946905,0.364805335) hint = "The Julia set coordinates." endparam param width caption = "Stalk Width and Max W" default = (0.01,4) hint = "Stalk Width and Max W." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Newt5_Stalks_Mset {; Paul W. Carlson init: bool done = FALSE rc = real(#pixel) ; c = #pixel - 2 * rc * (rc > 0);<== fails with strict type checking IF (rc > 0) c = #pixel - 2 * rc ELSE c = #pixel ENDIF a = 3 * c - 1 / c w = (sqrt(9 * a * a + 96) - 3 * a) / 12 range_num = 0 stalk_width = real(@SizeSkip) num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width prev_mod2 = |w| iter = 0 ;The color at maximum iterations #z = 252 loop: ;The equations we're iterating w2 = w * w w = (3*w2*w2+2*a*w*w2-4*w2-3)/(4*w*w2+3*a*w2-8*w-a) ;The usual 3D stalks rendering IF (abs(real(w)) <= abs(imag(w))) dist = abs(real(w)) ELSE dist = abs(imag(w)) ENDIF IF (dist < stalk_width && iter > imag(@SizeSkip)) z = index_factor * dist + range_num * colors_in_range done = TRUE ELSEIF (abs(|w| - prev_mod2) < 0.000001) ;The color when point doesn't move much #z = 252 done = TRUE ENDIF prev_mod2 = |w| ;Loop thru color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < @MaxW default: title = "Newton 5 Stalks" maxiter = 255 param SizeSkip caption = "Size and Skip" default = (0.2,0) hint = "Stalk size and iters to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam param MaxW caption = "Max. |z| for bailout" default = 1E20 hint = "Max. |z| for bailout." endparam } MyEqn_Julia {; Paul W. Carlson init: bool done = FALSE bool first = TRUE float range_num = 0 complex c = @JuliaCoords float dist = 1.0e20 float num_ranges = 2 float colors_in_range = 125 float index_factor = 124.0 / @size w = #pixel #z = 253 loop: complex w2 = w * w complex w = c * (1 - w2) / (1 + w2) complex a = 2 * atan(imag(w) / real(w)) a = a * a + c a = exp(1 - a) / a dist = abs(|w| - |a|) IF (dist < @size && first == FALSE) done = TRUE #z = index_factor * dist + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > 1.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE && |w| < 1.0e20 default: title = "Four Julia Sets" maxiter = 251 param JuliaCoords caption = "Julia Coordinates" default = (0.15,1.26875) hint = "The Julia set coordinates." endparam param size caption = "Element size" default = 0.3 hint = "Element size." endparam } BubsJulia {; Paul Carlson init: bool done = FALSE w = #pixel c = @JuliaCoords range_num = 0 max_w = imag(@SizeMaxW) size = real(@SizeMaxW) num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) /size min_w = 1.0e20 #z = 253.0 ;color for max. iterations loop: w = w * w + c ;Get smallest value and save the color range temp = sqrt(|w|) IF (temp < min_w) min_w = temp save_range = range_num ENDIF ;If beyond maximum value we will bail out... IF (|w| > max_w) ; ...but first we check if smallest value is within size IF (min_w < size) #z = index_factor * min_w + save_range * colors_in_range ELSE #z = 253.0 ;background color ENDIF done = TRUE ENDIF ;Cycle thru color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE && |w| < max_w default: title = "Julia Bubbles" maxiter = 255 param JuliaCoords caption = "Julia Coordinates" default = (-0.746410388,0.184309007) hint = "The Julia set coordinates." endparam param SizeMaxW caption = "Size and Max. w" default = (0.188,16) hint = "Bubble Size and Max. w." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } CTan_Trunc {; Paul Carlson init: bool done = FALSE bool first = TRUE w = #pixel c = @JuliaCoords range_num = 0 stalk_width = real(@WidthMaxW) max_wm = imag(@WidthMaxW) num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width loop: ;The equation we're iterating w = c * tan(w) ;The usual stalk stuff... awr = abs(real(w)) awi = abs(imag(w)) IF (awr <= awi) dist = awr ELSE dist = awi ENDIF ; ...but we truncate the stalks when |w| >= max_wm IF (dist < stalk_width && |w| < max_wm && first == FALSE) #z = index_factor * dist + range_num * colors_in_range done = TRUE ENDIF ;Cycle thru the color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE && |w| < 4 default: title = "CTan Truncated" maxiter = 5000 param JuliaCoords caption = "Julia Coordinates" default = (0.9,0.0) hint = "The Julia set coordinates." endparam param width caption = "Stalk Width and Max W" default = (0.03,0.1) hint = "Stalk Width and Max W." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Cosh_Tan_Mset {; Paul Carlson init: bool done = FALSE float size = real(@width) float range_num = 0 complex c = #pixel complex w = 0 #z = 253 loop: complex prev_w = w w = cosh(tan(prev_w)) + c IF (abs(real(w)) > size) done = TRUE float angle = abs(atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))) float index = 250.0 * angle / #pi #z = index + range_num * 125.0 + 1.0 ENDIF range_num = range_num + 1 IF (range_num > 1.5) range_num = 0.0 ENDIF bailout: done == FALSE default: title = "Cosh Tan Mset" maxiter = 1000 param width caption = "Width Factor" default = 2.0 hint = "Controls element size." endparam } Newton_3Way {; Paul Carlson ; Newton's method solution of z^k - 1 = 0 init: bool done = FALSE float range_num = 0 complex w = #pixel float prev_modw2 = 1.0e20 float rad2 = @radsqd float k = @expon float km1 = k - 1 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float colors_in_range_1 = colors_in_range - 1 #z = 253 loop: w = w - @relax * ((w^k) - 1) / (k * (w^km1)) IF ((prev_modw2 < rad2) && (|w| > rad2)) done = TRUE float idx = colors_in_range_1 * (rad2 - prev_modw2) / rad2 #z = idx + range_num * colors_in_range ENDIF prev_modw2 = |w| range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE default: title = "Newton 3-Way" maxiter = 255 param radsqd caption = "Bailout Radius Squared" default = 1.0 hint = "Bailout Radius Squared." endparam param expon caption = "Exponent of Z" default = 3.0 hint = "Exponent of Z." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } Carr2821b { ; This is one-half of Bob Carr's Carr2821 PHC formula ; as modified and optimized by Sylvie Gallet ; Half the formula extracted by Paul Carlson m = 0.1/pixel , z = c = conj(m) - pixel , r = |z| k = m*(-0.9) , p = k + flip(m) + conj(0.01*m) - pixel bailout = 16 , im1 = imag(p1) , im2 = imag(p2) iter = 0 : IF (iter == p1) p = (c^1.2)*1.5 + k , r = z = 0 ELSEIF (iter == im1) p = conj(c)*2.25 + k , r = z = 0 ELSEIF (iter == p2) p = flip(c)*3.375 + k , r = z = 0 ELSEIF (iter == im2) p = flip(c)*5.0625 + k , r = z = 0 ENDIF iter = iter + 1 , z = real(r)*0.2 + sqr(z) + p , r = |z| r <= bailout } NewtErr_Mset {; Paul Carlson init: bool done = FALSE bool first = TRUE c = sqr(#pixel) a = c - 1 / c w = sqrt(a / 6) range_num = 0 stalk_width = @width num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width #z = 252 loop: w2 = w * w w = (3 * w2*w2 - a*w2 - 1) / (4*w2*w - 2*a*w) IF (abs(real(w)) <= abs(imag(w))) dist = abs(real(w)) ELSE dist = abs(imag(w)) ENDIF IF (dist < stalk_width && First == FALSE) #z = index_factor * dist + range_num * colors_in_range done = TRUE ENDIF prev_mod2 = |w| range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE && |w| < @MaxZ default: title = "Newton Error Stalks" maxiter = 500 param width caption = "Stalk Width" default = 0.1 hint = "Controls stalk width." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam param MaxZ caption = "Max. |z| for bailout" default = 1E20 hint = "Max. |z| for bailout." endparam } Mset_Rings {; Paul Carlson init: bool done = FALSE bool first = TRUE complex w = 0 complex c = #pixel complex cm1 = c - 1 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float tcr = colors_in_range + colors_in_range float range_num = 0 float ring_width = @width float index_factor = (colors_in_range - 1) / ring_width int iter = 0 ;The background color #z = 254 loop: complex prev_w = w complex w2 = w * w w = (w2 * w - w2 - w2 - 1) / cm1 + c ;If the point falls in the ring... dist = abs(|w|-.25) IF (dist < ring_width && iter > @SkipIters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSE ;Force bailout to get the color for max iterations IF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF ENDIF ;Cycle thru the color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Mset Rings" maxiter = 5000 param width caption = "Ring Width Factor" default = 0.113 hint = "Controls ring width." endparam param SkipIters caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } MyEqn_Rings {; Paul Carlson init: bool done = FALSE bool first = TRUE complex w = #pixel complex c = @JuliaCoords float ring_width = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / ring_width float range_num = 0 #z = 252 loop: complex w2 = w * w w = c * (1 - w2) / (1 + w2) float dist = abs(|w|-.25) IF (dist < ring_width && first == FALSE) done = TRUE #z = index_factor * dist + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.05) range_num = 0.0 ENDIF first = FALSE bailout: done == FALSE && |w| < 1.0e20 default: title = "MyEqn Rings" maxiter = 300 param JuliaCoords caption = "Julia Coordinates" default = (1.240929178,0.881773806) hint = "The Julia set coordinates." endparam param width caption = "Width Factor" default = 0.3 hint = "Controls element size." endparam param RangesColors caption = "Ranges and Colors" default = (1,250) hint = "# co color ranges and # of colors in range." endparam } BAser2M2 {; Paul Carlson init: bool done = FALSE complex w = 0.0 float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 int iter = 0 #z = 254 loop: complex w2 = w * w complex w4 = 0.01 * w2 * w2 complex w8 = w4 * w4 complex w12 = w4 * w8 complex w16 = w4 * w12 ;The series we're iterating w = w2 - w4 - w8 - w12 - w16 + #pixel float wr=real(w) float wi=imag(w) ;Get distance to center of each cirlce float b1 = wr * wr + (wi - 0.5) * (wi - 0.5) float b2 = wr * wr + (wi + 0.5) * (wi + 0.5) float b3 = (wr - 0.5) * (wr - 0.5) + wi * wi float b4 = (wr + 0.5) * (wr + 0.5) + wi * wi ;If the point landed in a circle... IF (iter > 0) IF (b1 < size) float dist = b1 done = TRUE ELSEIF (b2 < size) dist = b2 done = TRUE ELSEIF (b3 < size) dist = b3 done = TRUE ELSEIF (b4 < size) dist = b4 done = TRUE ENDIF ENDIF IF (done == TRUE) #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1e20 default: title = "Ball Series" maxiter = 3000 param width caption = "Size of balls" default = 0.028 hint = "Size of balls." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Zf_Ang {; Paul Carlson init: bool done = FALSE int iter = 0 float range_num = 0 complex w = #pixel complex c = @JuliaCoords float size = @width int skip_iters = @skip float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float factor = (colors_in_range - 1) / size loop: w = c * (w - 1 / w) complex a = 2 * atan(imag(w) / real(w)) a = a * a + c a = fn1(1 - a) / a float dist = abs(|w| - |a|) IF (dist < size && iter > skip_iters) done = TRUE #z = factor * dist + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Z Function Angle" maxiter = 1000 param width caption = "Width Factor" default = 0.3 hint = "Controls element size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param JuliaCoords caption = "Julia Coordinates" default = (-0.058182009,0.675191868) hint = "The Julia set coordinates." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Mandel_Squares {; Paul Carlson init: bool done = FALSE ;Plot Mset or Julia set? IF (@what == 0) complex c = #pixel complex w = 0 ELSE c = @JuliaCoords w = #pixel ENDIF float square_size = @size int skip_iters = @skip float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float k = 0.5 + square_size float j = 0.5 - square_size float index_factor = (colors_in_range - 1) / square_size float range_num = 0 int iter = 0 #z = 254 loop: ;The equation we're iterating w = w * w + c ;Check if the point is trapped... float awr = abs(real(w)) float awi = abs(imag(w)) IF ((awr < k) && (awr > j) && (awi < k) && (awi > j)) float awr5 = abs(awr - 0.5) float awi5 = abs(awi - 0.5) IF (awr5 <= awi5) float min_dist = awr5 ELSE min_dist = awi5 ENDIF IF (min_dist < square_size && iter > skip_iters) ;The point is trapped #z = index_factor * min_dist + range_num * colors_in_range done = TRUE ENDIF ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Mandel Squares" maxiter = 1000 param what caption = "What to plot" default = 0 hint = "Mset=0, Julia=1." endparam param JuliaCoords caption = "Julia Coordinates" default = (-0.746410388,0.184309007) hint = "The Julia set coordinates." endparam param size caption = "Square Size" default = 0.4 hint = "Controls Square Size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } RbAs2M2 {; Paul Carlson init: bool done = FALSE complex c = #pixel complex w = 0 float size = @width float psqd = size + size float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float index_factor = (colors_in_range - 1) / size int iter = 0 #z = 253 loop: complex w2 = w * w complex w4 = 0.01 * w2 complex w8 = w4 * w4 complex w12 = w4 * w8 w = w2 - (w4 + w8 - w12) * fn1(w) + c float rsqd = |w| IF (psqd < size && rsqd > size && iter > 2) done = TRUE #z = index_factor * (size - psqd) + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF psqd = rsqd iter = iter + 1 bailout: done == FALSE && |w|<1.0e20 default: title = "Series Function Mset" maxiter = 1000 param width caption = "Width Factor" default = 16 hint = "Controls element size." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Celtic_Julia {; Paul Carlson init: bool done = FALSE bool first = TRUE w = #pixel c = @JuliaCoords iter = 0 range_num = 0 stalk_width = real(@width) skip_iters = @skip num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width #z = 253 loop: ;The equations we're iterating w = w * w wr = real(w) w = w - wr + abs(wr) - c ;The usual stalk stuff... awr = abs(real(w)) awi = abs(imag(w)) IF (awr <= awi) dist = awr ELSE dist = awi ENDIF ; If the point is trapped IF (dist < stalk_width && iter > skip_iters) #z = index_factor * dist + range_num * colors_in_range done = TRUE ENDIF ;Cycle thru the color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 4 default: title = "Celtic Julia" maxiter = 255 param JuliaCoords caption = "Julia Coordinates" default = (0.690498547,0.192997741) hint = "The Julia set coordinates." endparam param width caption = "Stalk Width" default = 0.1 hint = "Stalk Width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Mand_Atan_Mset {; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: complex prev_w = w w = w * w + c IF (abs(real(w)) > size && iter > skip_iters) done = TRUE float angle = abs(atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))) #z = index_factor * angle + range_num * colors_in_range ELSE IF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE default: title = "Mand Atan Mset" maxiter = 3000 param width caption = "Max. value of abs(real(z))" default = 2.0 hint = "Max. value of abs(real(z))." endparam param skip caption = "Iterations to skip" default = -1 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } BrpccJ2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float size = @width float skip_iters = @skip float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 int iter = 0 #z = 254 loop: w = 1.0 / (w * w + c) + c float wr=real(w) float wi=imag(w) float b1 = wr * wr + (wi - 0.5) * (wi - 0.5) float b2 = wr * wr + (wi + 0.5) * (wi + 0.5) float b3 = (wr - 0.5) * (wr - 0.5) + wi * wi float b4 = (wr + 0.5) * (wr + 0.5) + wi * wi IF (iter > skip_iters) IF (b1 < size) float dist = b1 done = TRUE ELSEIF (b2 < size) dist = b2 done = TRUE ELSEIF (b3 < size) dist = b3 done = TRUE ELSEIF (b4 < size) dist = b4 done = TRUE ENDIF ENDIF IF (done == TRUE) #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1e20 default: title = "Balls Julia" maxiter = 3000 param JuliaCoords caption = "Julia Set Coordinates" default = (-1.28333,0.049167) hint = "Julia Set Coordinates." endparam param width caption = "Size of balls" default = 0.2 hint = "Size of balls." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } IMyfaJ8 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float ball_size = @width float k = @multiplier float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / ball_size int skip_iters = @skip int iter = 0 #z = 254 loop: w2 = w * w w = c * (1 - w2) / (1 + w2) a = k * atan(imag(w) / real(w)) a = a * a + c a = fn1(1 - a) / a dist = abs(|w| - |a|) IF (dist < ball_size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "MyEqn Julia Balls" maxiter = 500 param JuliaCoords caption = "Julia Set Coordinates" default = (2.89375,0.05625) hint = "Julia Set Coordinates." endparam param width caption = "Ball Width Factor" default = 0.03 hint = "Controls ball width." endparam param multiplier caption = "Angle multiplier" default = 1.0 hint = "Angle multiplier." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } HNspirJ2 {; Paul Carlson init: bool done = FALSE complex i = (0,1) complex w = #pixel complex c = @JuliaCoords float range_num = 0 float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size int skip_iters = @skip int iter = 0 #z = 254 loop: w = sqr(w) wr = real(w) awr = abs(wr) w = w - wr + awr - c a = atan(imag(w) / real(w)) k = 1.2 - @hfactor ka = k * a / @hfactor rw = k * cos(a) + @hfactor * cos(ka) iw = k * sin(a) + @hfactor * sin(ka) v = rw + i * iw dist = abs(|w| - |v|) IF (dist < size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Hypocycloid Julia" maxiter = 5000 param JuliaCoords caption = "Julia Set Coordinates" default = (0.782397227416,0.156915323723) hint = "Julia Set Coordinates." endparam param width caption = "Stalk Width Factor" default = 0.03 hint = "Controls stalk width." endparam param hfactor caption = "Hypocycloid Factor" default = 0.4 hint = "Hypocycloid Factor." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } BrtryJ2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float size = @width float skip_iters = @skip float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 int iter = 0 #z = 254 loop: w = w * w * c / (c + 1) + c float wr=real(w) float wi=imag(w) float b1 = wr * wr + (wi - 0.5) * (wi - 0.5) float b2 = wr * wr + (wi + 0.5) * (wi + 0.5) float b3 = (wr - 0.5) * (wr - 0.5) + wi * wi float b4 = (wr + 0.5) * (wr + 0.5) + wi * wi IF (iter > skip_iters) IF (b1 < size) float dist = b1 done = TRUE ELSEIF (b2 < size) dist = b2 done = TRUE ELSEIF (b3 < size) dist = b3 done = TRUE ELSEIF (b4 < size) dist = b4 done = TRUE ENDIF ENDIF IF (done == TRUE) #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1e20 default: title = "Julia Set with Balls" maxiter = 500 param JuliaCoords caption = "Julia Set Coordinates" default = (0.74625,0.05875) hint = "Julia Set Coordinates." endparam param width caption = "Size of balls" default = 0.2 hint = "Size of balls." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } ISStAxJ2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: complex w2 = w * w w = c * (1 - w2) / (1 + w2) a = @multiplier * atan(imag(w) / real(w)) a = a * a + c a = fn1(1 - a) / a float dist = abs(|w|-|a|) IF (dist < size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.05) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "MyEqn Stalks 2" maxiter = 1000 param JuliaCoords caption = "Julia Coordinates" default = (0.78919240926,0.209742143344) hint = "The Julia set coordinates." endparam param width caption = "Width Factor" default = 0.3 hint = "Controls element size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param multiplier caption = "Angle Multiplier" default = 1 hint = "Angle Multiplier." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Mod_Pokorny_Rings {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float ring_width = @width float index_factor = (colors_in_range - 1) / ring_width int skip_iters = @skip int inter = 0 #z = 254 loop: w = 1.0 / (w * w + c) + c dist = abs(|w|-.25) IF (dist < ring_width && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Pokorny Rings" maxiter = 5000 param JuliaCoords caption = "Julia Set Coordinates" default = (0.74625,0.05875) hint = "Julia Set Coordinates." endparam param width caption = "Ring Width Factor" default = 2.0 hint = "Controls ring width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Two_Ellipse_Mset {; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel complex i = (0,1) float width = @size float range_num = 0 float a1 = @major1 float b1 = @minor1 float a2 = @major2 float b2 = @minor2 float index_factor = 124 / width int skip_iters = @skip int iter = 0 #z = 255 loop: w = w * w + c float ang = atan(imag(w) / real(w)) complex ell1 = a1 * cos(ang) + i * b1 * sin(ang) complex ell2 = b2 * cos(ang) + i * a2 * sin(ang) float dist1 = abs(cabs(w) - cabs(ell1)) float dist2 = abs(cabs(w) - cabs(ell2)) IF (dist1 < dist2) range_num = 0.0 float distance = dist1 ELSE range_num = 1.0 distance = dist2 ENDIF IF (distance < width && iter > skip_iters) #z = index_factor * distance + range_num * 125 done = TRUE ELSE IF (iter == #maxiter - 2) done = TRUE #z = 253 ENDIF ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1000 default: title = "Two Ellipes Mset" maxiter = 2000 param size caption = "Ellipse Width Factor" default = 0.1 hint = "Controls ellipse width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param major1 caption = "Ellipse 1 Major Axis" default = 0.6 hint = "Ellipse 1 Major Axis." endparam param major2 caption = "Ellipse 2 Major Axis" default = 0.2 hint = "Ellipse 2 Major Axis." endparam param minor1 caption = "Ellipse 1 Minor Axis" default = 0.6 hint = "Ellipse 1 Minor Axis." endparam param minor2 caption = "Ellipse 2 Minor Axis" default = 0.2 hint = "Ellipse 2 Minor Axis." endparam } RbsLogM8 {; Paul Carlson init: bool done = FALSE complex c = #pixel complex w = 0 float size = @width float psqd = size + size float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float index_factor = (colors_in_range - 1) / size int skip_iters = @skip int iter = 0 #z = 254 loop: complex w2 = w * w complex w4 = w2 * w2 complex w6 = w2 * w4 complex w8 = w4 * w4 complex w10 = w6 * w4 complex w12 = w6 * w6 w = w2 - w4/2 + w6/3 - w8/4 + w10/5 - w12/6 + c float rsqd = |w| IF (psqd < size && rsqd > size && iter > skip_iters) done = TRUE #z = index_factor * (size - psqd) + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 255 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF psqd = rsqd iter = iter + 1 bailout: done == FALSE && |w|<1.0e20 default: title = "Rbs Series Mset" maxiter = 1000 param width caption = "Width Factor" default = 4 hint = "Controls element size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Dbl_Expos_Newt1 {; Paul Carlson init: bool done = FALSE float range_num = 0 float dist = 0 complex c = #pixel complex csqd = c * c complex icsqd = 1 / csqd complex sc = sqrt(-icsqd) complex a = csqd - icsqd complex w = sqrt(a / 6) float stalk_width = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / stalk_width int skip_iters = @skip int iter = 0 #z = 254 loop: complex w2 = w * w w = (3 * w2 * w2 - a * w2 + 1) / (4 * w * w2 - 2 * a * w) IF (iter > skip_iters) ; Get minimum distance to an axis IF (abs(real(w)) <= abs(imag(w))) float min_dist = abs(real(w)) ELSE min_dist = abs(imag(w)) ENDIF ;Check for stalk IF (dist == 0 && min_dist < stalk_width) dist = min_dist ENDIF ;Bailout depends on convergence to a root IF (|w + c| < 1E-7) done = TRUE ELSEIF (|w - c| < 1E-7) done = TRUE ELSEIF (|w + sc| <1E-7) done = TRUE ELSEIF (|w - sc| < 1E-7) done = TRUE ENDIF ENDIF IF (done == TRUE) #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ;Cycle thru color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1E20 default: title = "Doulbe Exposure Newton 1" maxiter = 2000 param width caption = "Stalk Width Factor" default = 0.1 hint = "Controls stalk width." endparam param skip caption = "Iterations to skip" default = 25 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Qd_Julia {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float ball_size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / ball_size int skip_iters = @skip int iter = 0 #z = 254 loop: w = c * (w * w + w) - c float wr = real(w) float wi = imag(w) float d = wr * wr + (wi - .5) * (wi - .5) IF (d < ball_size) done = TRUE ENDIF IF (done == FALSE) d = wr * wr + (wi + .5) * (wi + .5) IF (d < ball_size) done = TRUE ENDIF ENDIF IF (done == FALSE) d = wi * wi + (wr - .5) * (wr - .5) IF (d < ball_size) done = TRUE ENDIF ENDIF IF (done == FALSE) d = wi * wi + (wr + .5) * (wr + .5) IF (d < ball_size) done = TRUE ENDIF ENDIF ; IF (done == TRUE && iter > skip_iters) #z = index_factor * (ball_size - d) + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "CZcubed Balls" maxiter = 5000 param JuliaCoords caption = "Julia Set Coordinates" default = (-0.38769624,-0.27939799) hint = "Julia Set Coordinates." endparam param width caption = "Ball Width Factor" default = 0.03 hint = "Controls ball width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } PhxAtanJ2 {; Paul Carlson init: bool done = FALSE complex prev_w = #pixel complex v = #pixel complex c = @JuliaCoords float range_num = 0 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi #z = 253 loop: w = prev_w * prev_w - 0.5 * prev_w + c complex b = w * w - 0.5 * v + c v = w w = b IF (abs(real(w)) > @MaxReal) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE default: title = "Phoenix Atan" maxiter = 1000 param JuliaCoords caption = "Julia Coordinates" default = (-0.50756510417,0.22080729167) hint = "The Julia set coordinates." endparam param MaxReal caption = "Max. Value for Real Z" default = 0.5 hint = "Max. Value for Real Z." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Petals_Barnsley1 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float r = @size complex ir = flip(r) float r2 = r * r float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = colors_in_range / (r2 + r2) #z = 254 loop: IF (real(w) >= 0) w = (w - 1) * c ELSE w = (w + 1) * c ENDIF bool c1 = (|w - r| < r2) bool c2 = (|w + ir| < r2) bool c3 = (|w + r| < r2) bool c4 = (|w - ir| < r2) IF (c1 && c4) float d = |w - r - ir| ELSEIF (c1 && c2) d = |w - r + ir| ELSEIF (c2 && c3) d = |w + r + ir| ELSEIF (c3 && c4) d = |w + r - ir| ELSE d = -1 ENDIF IF (d > 0) done = TRUE z = index_factor * d + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE && |w| < 1.0e20 default: title = "Barnsley Petals 1" maxiter = 241 param JuliaCoords caption = "Julia Set Coordinates" default = (1,1) hint = "Julia Set Coordinates." endparam param width caption = "Stalk Width Factor" default = 0.1 hint = "Controls stalk width." endparam param size caption = "Petals size factor" default = 0.8 hint = "Petals size factor." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } R4_Julia {; Paul Carlson init: bool done = FALSE complex w = #pixel complex k = (0.5,0.5) complex c = @JuliaCoords float size = real(@SizeSkip) float skip = imag(@SizeSkip) float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 float iter = 0 #z = 254 loop: w = w * w + c IF (iter > skip) dist = abs(|w - k| - 0.1) IF (dist < size) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 10000 default: title = "Four Rings Julia" maxiter = 2000 param JuliaCoords caption = "Julia Coordinates" default = (-0.770930835891489,-0.11602512199932) hint = "The Julia set coordinates." endparam param SizeSkip caption = "Size and Skip" default = (0.2,0) hint = "Ring size and iters to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } CsinzJ8 {; Paul Carlson init: bool done = FALSE complex prev_w = #pixel complex c = @JuliaCoords float range_num = 0 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi #z = 253 loop: w = c * sin(prev_w) IF (abs(real(w)) > @MaxReal) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE default: title = "CsinZ Atan" maxiter = 5000 param JuliaCoords caption = "Julia Coordinates" default = (0.56204688,0.526652813) hint = "The Julia set coordinates." endparam param MaxReal caption = "Max. Value for Real Z" default = 1.35 hint = "Max. Value for Real Z." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } NtryJ2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: w = (w + c) * (w + c) * c / (c + 1) + c float wr = real(w) float wi = imag(w) float b1 = wr * wr + (wi - 0.5) * (wi - 0.5) float b2 = wr * wr + (wi + 0.5) * (wi + 0.5) float b3 = (wr - 0.5) * (wr - 0.5) + wi * wi float b4 = (wr + 0.5) * (wr + 0.5) + wi * wi IF (iter > skip_iters) IF (b1 < size) float dist = b1 done = TRUE ELSEIF (b2 < size) dist = b2 done = TRUE ELSEIF (b3 < size) dist = b3 done = TRUE ELSEIF (b4 < size) dist = b4 done = TRUE ENDIF ENDIF IF (done == TRUE) #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1e20 default: title = "Balls Julia 2" maxiter = 3000 param JuliaCoords caption = "Julia Coordinates" default = (0.50375,0.435) hint = "The Julia set coordinates." endparam param width caption = "Size of balls" default = 0.02 hint = "Size of balls." endparam param skip caption = "Iterations to skip" default = 1 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } ASerM2 {; Paul Carlson init: bool done = FALSE complex c = #pixel complex prev_w = 0 float range_num = 0 float max_real = @MaxReal float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) int iter = 0 #z = 254 loop: complex w2 = prev_w * prev_w complex w4 = 0.01 * w2 * w2 complex w8 = w4 * w4 complex w12 = w4 * w8 complex w16 = w4 * w12 complex w = w2 - w4 - w8 - w12 - w16 + c IF (abs(real(w)) > max_real) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) float range_index = 2.0 * colors_in_range * ang / #pi #z = range_index + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 w = 1.0e20 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF prev_w = w iter = iter + 1 bailout: done == FALSE default: title = "MySeries2 Atan Mset" maxiter = 5000 param MaxReal caption = "Max. value of abs(real(z))" default = 0.8 hint = "Max. value of abs(real(z))." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } BZtoz2J8 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: w = c * w w = c * w^w + c float wr=real(w) float wi=imag(w) float b1 = wr * wr + (wi - 0.5) * (wi - 0.5) float b2 = wr * wr + (wi + 0.5) * (wi + 0.5) float b3 = (wr - 0.5) * (wr - 0.5) + wi * wi float b4 = (wr + 0.5) * (wr + 0.5) + wi * wi IF (iter > skip_iters) IF (b1 < size) float dist = b1 done = TRUE ELSEIF (b2 < size) dist = b2 done = TRUE ELSEIF (b3 < size) dist = b3 done = TRUE ELSEIF (b4 < size) dist = b4 done = TRUE ENDIF ENDIF IF (done == TRUE) #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1e20 default: title = "Cztoz2 Balls" maxiter = 300 param width caption = "Size of balls" default = 0.01 hint = "Size of balls." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param JuliaCoords caption = "Julia Coordinates" default = (0.0,0.895) hint = "The Julia set coordinates." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } ACoshJ2 {; Paul Carlson init: bool done = FALSE complex prev_w = #pixel complex c = @JuliaCoords float range_num = 0 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi int skip_iters = @skip int iter = 0 #z = 253 loop: w = cosh(prev_w) + c IF (abs(real(w)) > @MaxReal && iter > skip_iters) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE default: title = "Cosh Atan Julia" maxiter = 300 param JuliaCoords caption = "Julia Coordinates" default = (-3.317058,1.702923) hint = "The Julia set coordinates." endparam param MaxReal caption = "Max. Value for Real Z" default = 16 hint = "Max. Value for Real Z." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } CshSnM2 {; Paul Carlson init: bool done = FALSE complex prev_w = 0 complex c = #pixel float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: complex w = cosh(prev_w) + c w = sin(w) + c IF (abs(real(w)) > @MaxReal && iter > skip_iters) done = TRUE float angle = abs(atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))) #z = index_factor * angle + range_num * colors_in_range ELSE IF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF prev_w = w iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "Cosh Sin Atan Mset" maxiter = 500 param MaxReal caption = "Max. value of abs(real(z))" default = 4.0 hint = "Max. value of abs(real(z))." endparam param skip caption = "Iterations to skip" default = -1 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } PwcLyap1 { ; Paul Carlson init: bool done = FALSE float MaxLyap = 0.0 float MinLyap = -3.0 float Lyap = 0.0 float a = imag(#pixel) float b = real(#pixel) float Index_factor = 0.0 float total = 0.0 float x = 0.05 float deriv = 0.0 float Log2e = log(2.0) float j = 0.0 float r = b int settle = 200 int dwell = 1000 int n = 0 loop: WHILE (settle > 0) IF (n == 2 || n == 4 || n == 6) r = a ElSE r = b ENDIF x = r * x * (1.0 - x) settle = settle - 1 n = n + 1 IF (n == 7) n = 0 ENDIF ENDWHILE WHILE (dwell > 0) IF (n == 2 || n == 4 || n == 6) r = a ElSE r = b ENDIF x = r * x * (1.0 - x) deriv = abs(r - 2.0 * r * x) total = total + log(deriv) dwell = dwell - 1 j = j + 1.0 n = n + 1 IF (n == 7) n = 0 ENDIF ENDWHILE done = TRUE Lyap = (total * Log2e) / j IF (Lyap >= MaxLyap) #z = 150.0 ELSEIF (Lyap < MaxLyap && Lyap > MinLyap) Index_factor = (Lyap - MinLyap) / (MaxLyap - MinLyap) #z = Index_factor * 125.0 ELSE #z = 200.0 ENDIF bailout: done == FALSE } RsNewtMset2 { ; Paul Carlson init: bool first = TRUE bool done = FALSE float HalfT = 0.5 * @T float Phi = #pi * 0.125 float Ro = @Rm + HalfT float Py = @Rm*sin(Phi) float Px = @Rm*cos(Phi) float Dsqd = @Rm*@Rm + Ro*Ro - 2*Ro*Px complex C = #pixel W = -c/3 #Z = 254 loop: complex W2 = W * W complex Err = (w * w2 + c * w2 + w + c) / (3 * w2 + 2 * c * w + 1) W = W - Err IF ((abs(cabs(W) - @Rm) < HalfT) && first == FALSE) done = TRUE float X = real(W) float Y = imag(W) float Xabs = abs(X) float Yabs = abs(Y) IF (Xabs >= Yabs) float WtoPsqd = (Xabs-Px)*(Xabs-Px) + (Yabs-Py)*(Yabs-Py) ELSE WtoPsqd = (Xabs-Py)*(Xabs-Py) + (Yabs-Px)*(Yabs-Px) ENDIF IF (X >= 0 && Y >= 0) IF (Xabs >= Yabs) float Segment = 0 ELSE Segment = 1 ENDIF ELSEIF (X < 0 && Y >= 0) IF (Xabs < Yabs) Segment = 2 ELSE Segment = 3 ENDIF ELSEIF (X < 0 && Y < 0) IF (Xabs >= Yabs) Segment = 4 ELSE Segment = 5 ENDIF ELSE IF (Xabs < Yabs) Segment = 6 ELSE Segment = 7 ENDIF ENDIF float Ratio = sqrt(WtoPsqd/Dsqd) #Z = 29.0 * Ratio + Segment * 30.0 ELSEIF (|Err| < 0.000001) done = TRUE #Z = 251 ENDIF first = FALSE bailout: done == FALSE default: title = "Ring Segments Newton2 Mset" maxiter = 3000 param Rm caption = "Ring radius" default = 1.3 hint = "The radius to the midline of the ring." endparam param T caption = "Ring thickness" default = 0.2 hint = "The thickness of the ring." endparam } PwcLyap { ; Paul Carlson init: bool done = TRUE float MaxLyap = @MaxLy float MinLyap = @MinLy IF(@Eqn == 3) float coef = 0.5/(1.0-1.0/sqrt(#e)) float y_offset = 0.7707470412684 ELSEIF (@Eqn == 5) float cosh1 = cosh(1.0) ENDIF float a = real(#pixel) float b = imag(#pixel) float r = b float Lyap = 0.0 float Index_factor = 0.0 float total = 0.0 float x = 0.05 float deriv = 0.0 float Log2e = log(2.0) float DwellCount = 0.0 int SettleIters = @Settle int DwellIters = @Dwell int n = 0 float r = b loop: WHILE (SettleIters > 0) IF ((n == 0 && @a1 == 1) || \ (n == 1 && @a2 == 1) || \ (n == 2 && @a3 == 1) || \ (n == 3 && @a4 == 1) || \ (n == 4 && @a5 == 1) || \ (n == 5 && @a6 == 1) || \ (n == 6 && @a7 == 1) || \ (n == 7 && @a8 == 1) || \ (n == 8 && @a9 == 1) || \ (n == 9 && @a10 == 1) || \ (n == 10 && @a11 == 1) || \ (n == 11 && @a12 == 1) || \ (n == 12 && @a13 == 1) || \ (n == 13 && @a14 == 1) || \ (n == 14 && @a15 == 1) || \ (n == 15 && @a16 == 1)) r = a ElSE r = b ENDIF IF (@Eqn == 0) x = r * x * (1.0 - x) ELSEIF (@Eqn == 1) x = r * x * (1.0 - x) * (1.0 - x) ELSEIF (@Eqn == 2) x = r * sin(#pi * x) ELSEIF (@Eqn == 3) x = r*(coef*exp(-2.0*x*x+x+x-0.5)-y_offset) ELSEIF (@Eqn == 4) x = r * sqrt(abs(x - x*x)) ELSEIF (@Eqn == 5) x = r * cosh1 - cosh(2.0 * x - 1.0) ENDIF SettleIters = SettleIters - 1 n = n + 1 IF (n == @SequenceLen) n = 0 ENDIF ENDWHILE WHILE (DwellIters > 0) IF ((n == 0 && @a1 == 1) || \ (n == 1 && @a2 == 1) || \ (n == 2 && @a3 == 1) || \ (n == 3 && @a4 == 1) || \ (n == 4 && @a5 == 1) || \ (n == 5 && @a6 == 1) || \ (n == 6 && @a7 == 1) || \ (n == 7 && @a8 == 1) || \ (n == 8 && @a9 == 1) || \ (n == 9 && @a10 == 1) || \ (n == 10 && @a11 == 1) || \ (n == 11 && @a12 == 1) || \ (n == 12 && @a13 == 1) || \ (n == 13 && @a14 == 1) || \ (n == 14 && @a15 == 1) || \ (n == 15 && @a16 == 1)) r = a ElSE r = b ENDIF IF (@Eqn == 0) x = r * x * (1.0 - x) deriv = r - 2.0 * r * x ELSEIF (@Eqn == 1) x = r * x * (1.0 - x) * (1.0 - x) deriv = r * (1.0 - 4.0*x + 3.0*x*x) ELSEIF (@Eqn == 2) x = r * sin(#pi * x) deriv = r * #pi * cos(#pi * x) ELSEIF (@Eqn == 3) x = r*(coef*exp(-2.0*x*x+x+x-0.5)-y_offset) deriv = r*(2.0 - 4.0*x)*coef*exp(-2.0*x*x+x+x-0.5) ELSEIF (@Eqn == 4) x = r * sqrt(abs(x - x*x)) deriv = r*(0.5-x)/sqrt(abs(x - x*x)) ELSEIF (@Eqn == 5) x = r * cosh1 - cosh(2.0 * x - 1.0) deriv = -2.0 * r * sinh(2.0 * x - 1.0) ENDIF total = total + log(abs(deriv)) DwellIters = DwellIters - 1 DwellCount = DwellCount + 1.0 n = n + 1 IF (n == @SequenceLen) n = 0 ENDIF ENDWHILE Lyap = (total * Log2e) / DwellCount IF (Lyap >= MaxLyap) #z = 150.0 ELSEIF (Lyap < MaxLyap && Lyap > MinLyap) Index_factor = (Lyap - MinLyap) / (MaxLyap - MinLyap) #z = Index_factor * 125.0 ELSE #z = 200.0 ENDIF bailout: done == FALSE default: title = "Lyapunov" param Eqn caption = "Equation" default = 0 enum = "Logistic" "Double Logistic" "Circular Arc" "Exponential" \ "Square Root" "Hyperbolic Cosine" hint = "Selects the type of equation to be iterated." endparam param SequenceLen caption = "Sequence Length" default = 3 endparam param Settle caption = "Settle Iterations" default = 200 endparam param Dwell caption = "Dwell Iterations" default = 1000 endparam param MaxLy caption = "Maximum Lyap Value" default = 0.0 endparam param MinLy caption = "Minimum Lyap Value" default = -3.0 endparam param a1 caption = "a1" default = 0 endparam param a2 caption = "a2" default = 0 endparam param a3 caption = "a3" default = 0 endparam param a4 caption = "a4" default = 0 endparam param a5 caption = "a5" default = 0 endparam param a6 caption = "a6" default = 0 endparam param a7 caption = "a7" default = 0 endparam param a8 caption = "a8" default = 0 endparam param a9 caption = "a9" default = 0 endparam param a10 caption = "a10" default = 0 endparam param a11 caption = "a11" default = 0 endparam param a12 caption = "a12" default = 0 endparam param a13 caption = "a13" default = 0 endparam param a14 caption = "a14" default = 0 endparam param a15 caption = "a15" default = 0 endparam param a16 caption = "a16" default = 0 endparam } Mag2StksJ {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords complex a = c - 1 complex b = a - 1 range_num = 0 float stalk_width = @Size float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1.0) / stalk_width int iter = 0 #z = 251 loop: w = ((w*w*w + 3*w*a + a*b) / (3*w*w + 3*w*b + a*b + 1))^2 float awr = abs(real(w)) float awi = abs(imag(w)) IF (awr <= awi) float dist = awr ELSE dist = awi ENDIF IF (dist < stalk_width && iter > 1) #z = index_factor * dist + range_num * colors_in_range done = TRUE ENDIF range_num = range_num + 1.0 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < @MaxW default: title = "Magnetism2 Stalks Julia" maxiter = 250 param JuliaCoords caption = "Julia Set Coordinates" default = (-0.25,0) hint = "Julia Set Coordinates." endparam param Size caption = "Size Factor" default = 0.1 hint = "Controls stalk width." endparam param MaxW caption = "Maximum |z|" default = 10000 hint = "Maximum value of |z|." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Mag2AtanM3 {; Paul Carlson init: bool done = FALSE bool first = TRUE complex c = #pixel complex a = c - 1 complex b = a - 1 complex p = 0 float range_num = 0 float max_real = @MaxReal float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi int iter = 0 #z = 251 loop: complex w = ((p*p*p + 3*p*a + a*b) / (3*p*p + 3*p*b + a*b + 1))^2 IF (abs(real(w)) > max_real) done = TRUE float delta_i = imag(w) - imag(p) float delta_r = real(w) - real(p) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ELSEIF (iter == #maxiter - 2 && abs(|w|-|p|) < 0.0001) ;Force color for maximum iterations done = TRUE #z = 254 ENDIF p = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF first = FALSE iter = iter + 1 bailout: done == FALSE && |w|<1.0e10 default: title = "Mag2 Atan Mset" maxiter = 1000 param MaxReal caption = "Max. Value for Real Z" default = 1.25 hint = "Max. Value for Real Z." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } PkyJ2 {; Paul Carlson init: bool done = FALSE complex prev_w = #pixel complex c = @JuliaCoords float range_num = 0 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / #pi #z = 253 loop: complex w = 1.0 / (prev_w * prev_w + c) IF (|w| > 4) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) IF (delta_r < 0.0) ang = #pi - ang ENDIF #z = index_factor * ang + range_num * colors_in_range ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE default: title = "Pokorny Cones Julia" maxiter = 1000 param JuliaCoords caption = "Julia Coordinates" default = (-1.550794271,0.023072917) hint = "The Julia set coordinates." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Newt2_Stalks_Mset {; Paul Carlson ; Newton's solution of (z*z-c*c)*(z*z+1/(c*c))=0 init: bool done = FALSE c = #pixel csqd = c * c icsqd = 1.0 / csqd sc = sqrt(-icsqd) a = csqd - icsqd w = sqrt(a / 6.0) cr1 = real(c) ci1 = imag(c) cr2 = real(sc) ci2 = imag(sc) stalk_width = @width range_num = 0 num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width stalks_iters = @stkiters skip_iters = @skip iter = 0 #z = 255 loop: w2 = w * w w = (3 * w2 * w2 - a * w2 + 1) / (4 * w * w2 - 2 * a * w) wr = real(w) wi = imag(w) IF (abs(wr) <= abs(wi)) min_dist = abs(wr) ELSE min_dist = abs(wi) ENDIF IF (min_dist < stalk_width && iter > skip_iters) #z = index_factor * min_dist + range_num * colors_in_range done = TRUE ENDIF ; If we're no longer looking for stalks, check if ; we've converged on a root. IF (done == FALSE && iter > stalks_iters) IF (((wr-cr1) * (wr-cr1) + (wi-ci1) * (wi-ci1)) < 0.00001) #z = 254 done = TRUE ELSEIF (((wr+cr1) * (wr+cr1) + (wi+ci1) * (wi+ci1)) < 0.00001) #z = 254 done = TRUE ELSEIF (((wr+cr2) * (wr+cr2) + (wi+ci2) * (wi+ci2)) < 0.00001) #z = 254 done = TRUE ELSEIF (((wr-cr2) * (wr-cr2) + (wi-ci2) * (wi-ci2)) < 0.00001) #z = 254 done = TRUE ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < @MaxZ default: title = "Newton2 Stalks Mset" maxiter = 2000 param width caption = "Stalk Width Factor" default = 0.1 hint = "Controls stalk width." endparam param stkiters caption = "Stalk Iterations" default = 100 hint = "Max. iterations to look for stalks." endparam param MaxZ caption = "Maximum value of |z|" default = 10000 hint = "Maximum value of |z|." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } NspirStalksJ {; Paul Carlson init: bool done = FALSE bool first = TRUE w = #pixel c = @JuliaCoords range_num = 0 stalk_width = real(@WidthMaxW) max_wm = imag(@WidthMaxW) num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width #z = 252 loop: ;The equations we're iterating w = w * w wr = real(w) awr = abs(wr) w = w - wr + awr - c ;The usual stalk stuff... awr = abs(real(w)) awi = abs(imag(w)) IF (awr <= awi) dist = awr ELSE dist = awi ENDIF IF (dist < stalk_width && first == FALSE) #z = index_factor * dist + range_num * colors_in_range done = TRUE ELSEIF (|w| >= max_wm) #z = 253 done = TRUE ENDIF ;Cycle thru the color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE default: title = "Nspir 3D Stalks Julia" maxiter = 300 param JuliaCoords caption = "Julia Coordinates" default = (0.55625,0.21875) hint = "The Julia set coordinates." endparam param width caption = "Stalk Width and Max W" default = (0.05,4) hint = "Stalk Width and Max W." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Rtry8J2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float ring_width = @width float index_factor = (colors_in_range - 1) / ring_width int skip_iters = @skip int inter = 0 #z = 254 loop: w = w * w, w = w * w, w = w * w + c dist = abs(|w|-.25) IF (dist < ring_width && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Try8 Rings" maxiter = 5000 param JuliaCoords caption = "Julia Set Coordinates" default = (0.696794,0.015455) hint = "Julia Set Coordinates." endparam param width caption = "Ring Width Factor" default = 0.18 hint = "Controls ring width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } R4MndStksM2 {; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float size = @width float index_factor = (colors_in_range - 1) / size int skip_iters = @skip int inter = 0 #z = 254 loop: w = w * w + c wr = real(w) wi = imag(w) dist=abs((wr-.5)*(wr-.5)+(wi-.5)*(wi-.5)-.1) IF (dist < size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Mandel Rings" maxiter = 5000 param width caption = "Width Factor" default = 2.0 hint = "Controls elements width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Mandel_Rings {; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float ring_width = @width float index_factor = (colors_in_range - 1) / ring_width int skip_iters = @skip int inter = 0 #z = 254 loop: w = w * w + c dist = abs(|w|-.25) IF (dist < ring_width && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Mandel Rings" maxiter = 5000 param width caption = "Ring Width Factor" default = 2.0 hint = "Controls ring width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } ItAserNewFnM2 {; Paul Carlson init: bool done = FALSE complex w = 0.0 float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: complex w2 = w * w complex w4 = 0.01 * w2 * w2 complex w8 = w4 * w4 complex w12 = w4 * w8 complex w16 = w4 * w12 w = w2 - w4 - w8 - w12 - w16 + #pixel a = atan(imag(w) / real(w)) complex v = @multiplier * fn1(w) / fn2(a) dist = abs(|w| - |v|) IF (dist < size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < @MaxW default: title = "Series Func Angle 2" maxiter = 1000 param width caption = "Width Factor" default = 0.03 hint = "Controls element width." endparam param multiplier caption = "Angle multiplier" default = 1.0 hint = "Angle multiplier." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param MaxW caption = "Maximum |z|" default = 100 hint = "Maximum |z|." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } IZNewtJ2 {; Paul Carlson init: bool done = FALSE complex c = @JuliaCoords complex prev_w = 1.0 / #pixel float range_num = 0 float max_real = @MaxReal float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi #z = 252 loop: complex k = prev_w^prev_w complex w = prev_w - (k - c) / (k * (1.0 + log(prev_w))) IF (abs(real(w)) > max_real ) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ELSEIF (|w| < 1.0e-10) #z = 252 done = TRUE ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE default: title = "Z^Z Newton" maxiter = 1000 param JuliaCoords caption = "Julia Set Coordinates" default = (7,0) hint = "Julia Set Coordinates." endparam param MaxReal caption = "Max. Value for Real Z" default = 8.0 hint = "Max. Value for Real Z." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } RbFnLambM2 {; Paul Carlson init: bool done = FALSE complex c = #pixel complex w = (0.5,0.0) float size = @width float psqd = size + size float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float index_factor = (colors_in_range - 1) / size #z = 253 loop: w = c * w * (1 - w) w = w - fn1(w) float rsqd = |w| IF (psqd < size && rsqd > size) done = TRUE #z = index_factor * (size - psqd) + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF psqd = rsqd bailout: done == FALSE && |w|<100 default: title = "Lambda Function Mset" maxiter = 5000 param width caption = "Width Factor" default = 4 hint = "Controls element size." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } FB_Halley_M4 {; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float r = @Radius float t = @Width float d0 = r + t float d1 = 0.382683432365 * t float d2 = 0.923879532511 * t float dsqd = d0 * d0 + t * t - (d0 + d0) * d2 int skip = @Skip int iter = 0 #z = 254 loop: complex w2 = w * w complex fnc = w2 * w2 - w - c complex der = 4 * w * w2 - 1 complex k = @Relax * fnc / (der - 12 * w2 * fnc / (der + der)) w = w - k IF ((abs(cabs(w) - r) < t) && iter > skip) done = TRUE float wr = real(w) float wi = imag(w) float awr = abs(wr) float awi = abs(wi) IF (awr >= awi) float dist = (awr - d2) * (awr - d2) + (awi - d1) * (awi - d1) adjust = 1 ELSE dist = (awr - d1) * (awr - d1) + (awi - d2) * (awi - d2) adjust = 0 ENDIF IF (wr >= 0 && wi >= 0) range_num = 1 - adjust ELSEIF (wr < 0 && wi >= 0) range_num = 2 + adjust ELSEIF (wr < 0 && wi < 0) range_num = 5 - adjust ELSE range_num = 6 + adjust ENDIF float ratio = sqrt(dist / dsqd) #z = 29 * ratio + range_num * 30 ELSEIF (|k| < 0.000001) done = TRUE #z = 251 ENDIF iter = iter + 1 bailout: done == FALSE default: title = "Halley FlexBalls Mset" maxiter = 251 param Relax caption = "Relaxation factor" default =1 hint = "Relaxation factor." endparam param Radius caption = "Ring Radius" default =1.0 hint = "Ring Radius." endparam param Width caption = "Ring Width" default = 0.8 hint = "Ring Width." endparam param Skip caption = "Iters to skip" default = -1 hint = "Iters to skip." endparam } MyEqn_Fnc_Jul {; Paul W. Carlson init: bool done = FALSE float range_num = 0 complex c = @JuliaCoords float dist = 1.0e20 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / @size int skip_iters = @skip int iter = 0 w = #pixel #z = 253 loop: complex w2 = w * w complex w = c * (1 - w2) / (1 + w2) complex a = @multiplier * atan(imag(w) / real(w)) a = a * a + c a = fn1(1 - a * a) dist = abs(|w| - |a|) IF (dist < @size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "MyEqn Fnc Julia" maxiter = 251 param JuliaCoords caption = "Julia Coordinates" default = (0.15,1.26875) hint = "The Julia set coordinates." endparam param size caption = "Element size" default = 0.3 hint = "Element size." endparam param skip caption = "Iterations to skip" default = 1 hint = "Iterations to skip." endparam param multiplier caption = "Angle multiplier" default = 0.2 hint = "Angle multiplier." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } RbASerM2 {; Paul Carlson init: bool done = FALSE complex c = #pixel complex w = 0 float size = @width float psqd = size + size float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float index_factor = (colors_in_range - 1) / size int iter = 0 #z = 253 loop: complex w2 = w * w complex w4 = 0.01 * w2 * w2 complex w8 = w4 * w4 complex w12 = w4 * w8 complex w16 = w4 * w12 w = w2 - w4 - w8 - w12 - w16 + c float rsqd = |w| IF (psqd < size && rsqd > size && iter > 2) done = TRUE #z = index_factor * (size - psqd) + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF psqd = rsqd iter = iter + 1 bailout: done == FALSE && |w|<1.0e20 default: title = "Series Function Mset" maxiter = 1000 param width caption = "Width Factor" default = 16 hint = "Controls element size." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Log_Ser_3Way {; Paul Carlson init: bool done = FALSE float r = @rad2 complex w = 0 float range_num = 0 complex c = #pixel float prev_modw2 = 1.0e20 int skipiters = @skip int iters = 0 #z = 253 loop: w2 = w * w w4 = w2 * w2 w6 = w2 * w4 w8 = w4 * w4 w10 = w6 * w4 w12 = w6 * w6 w = w2 - w4/2 + w6/3 - w8/4 + w10/5 - w12/6 + c IF ((prev_modw2 < r) && (|w| > r) && iters > skipiters) done = TRUE index = 124.0 * (r - prev_modw2) / r #z = index + range_num * 125.0 ENDIF prev_modw2 = |w| range_num = range_num + 1 IF (range_num > 1.5) range_num = 0 ENDIF iters = iters + 1 bailout: done == FALSE && |w| <= r default: title = "3-Way Log Series" maxiter = 2000 param rad2 caption = "Escape radius squared" default = 4.0 hint = "Escape radius squared." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Mod2_Pokorny_Rings {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float ring_width = @width float index_factor = (colors_in_range - 1) / ring_width int skip_iters = @skip int inter = 0 #z = 254 loop: w = 1.0 / (w * w + c) + c + 1 dist = abs(|w|-.25) IF (dist < ring_width && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Modified Pokorny Rings 2" maxiter = 5000 param JuliaCoords caption = "Julia Set Coordinates" default = (-2.25,0) hint = "Julia Set Coordinates." endparam param width caption = "Ring Width Factor" default = 2.0 hint = "Controls ring width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Flex_Newt2_Mand {; Paul Carlson init: bool done = FALSE complex c = #pixel complex c2 = c * c complex c41 = c2 * c2 + 1 complex w = sqrt(c41/(6*c2)) complex prev_w = w float r = @Rm float ht = @HalfT float d0 = r + ht float d1 = 0.382683432365 * r float d2 = 0.923879532511 * r float dsqd = d0 * d0 + r * r - (d0 + d0) * d2 int skip_iters = @skip int iter = 0 #z = 254.0 loop: complex w2 = w * w complex w3 = w2 * w complex w4 = w2 * w2 w = w - (c2*w4 - c41*w2 + c2) / (4*c2*w3 - 2*c41*w) IF ((abs(cabs(w) - r) < ht) && iter > skip_iters) done = TRUE float wr = real(w) float wi = imag(w) float awr = abs(wr) float awi = abs(wi) IF (awr >= awi) float dist = (awr - d2)*(awr - d2) + (awi - d1)*(awi - d1) float adjust = 1 ELSE dist = (awr - d1)*(awr - d1) + (awi - d2)*(awi - d2) adjust = 0 ENDIF IF (wr >= 0 && wi >= 0) float range_num = 1 - adjust ELSEIF (wr < 0 && wi >= 0) range_num = 2 + adjust ELSEIF (wr < 0 && wi < 0) range_num = 5 - adjust ELSE range_num = 6 + adjust ENDIF float ratio = sqrt(dist / dsqd) #z = 29.0 * ratio + range_num * 30.0 ELSEIF (|w - prev_w| < 1e-5) done = TRUE #z = 251.0 ENDIF iter = iter + 1 prev_w = w bailout: done == FALSE && |w| < 1.0e20 default: title = "Ring Segments Newton Mset 2" maxiter = 3000 param Rm caption = "Ring radius" default = 1.0 hint = "The radius to the midline of the ring." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param HalfT caption = "Half the ring thickness" default = 0.01 hint = "Half the thickness of the ring." endparam } MyEqnStlksJ {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float stalk_width = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / stalk_width float range_num = 0 int skip_iters = @skip int iter = 0 #z = 252 loop: complex w2 = w * w w = c * (1 - w2) / (1 + w2) float wr = real(w) float wi = imag(w) IF (abs(wr) <= abs(wi)) float min_dist = abs(wr) ELSE min_dist = abs(wi) ENDIF IF (min_dist < stalk_width && iter > skip_iters) done = TRUE #z = index_factor * min_dist + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.05) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "MyEqn Stalks Julia" maxiter = 500 param JuliaCoords caption = "Julia Coordinates" default = (2.89375,0.05625) hint = "The Julia set coordinates." endparam param width caption = "Width Factor" default = 0.1 hint = "Controls stalk size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } R4_Pokorny_Julia {; Paul Carlson init: bool done = FALSE complex w = #pixel complex k = (0.5,0.5) complex c = @JuliaCoords float size = real(@SizeSkip) float skip = imag(@SizeSkip) float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 float iter = 0 #z = 254 loop: w = 1.0 / (w * w + c) IF (iter > skip) dist = abs(|w - k| - 0.1) IF (dist < size) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 10000 default: title = "R4 Pokorny Julia" maxiter = 2000 param SizeSkip caption = "Size and Skip" default = (0.2,0) hint = "Ring size and iters to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam param JuliaCoords caption = "Julia Coordinates" default = (-1.5820911,-0.0374792) hint = "The Julia set coordinates." endparam } SymmFuncAng {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float size = @width float k = @multiplier float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size int skip_iters = @skip int iter = 0 #z = 254 loop: w = sqr(c / (c - abs((w - 1) / w))) complex a = atan(imag(w) / real(w)) complex v = k * fn1(a) float dist = abs(|w| - |v|) IF (dist < size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Symmetry Func Angle" maxiter = 500 param JuliaCoords caption = "Julia Set Coordinates" default = (0.3,0.5) hint = "Julia Set Coordinates." endparam param width caption = "Width Factor" default = 0.03 hint = "Controls element width." endparam param multiplier caption = "Angle multiplier" default = 1.0 hint = "Angle multiplier." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Flex_Newt2_Julia {; Paul Carlson init: bool done = FALSE complex c = @JuliaCoords complex c2 = c * c complex c41 = c2 * c2 + 1 complex w = #pixel complex prev_w = w float r = @Rm float ht = @HalfT float d0 = r + ht float d1 = 0.382683432365 * r float d2 = 0.923879532511 * r float dsqd = d0 * d0 + r * r - (d0 + d0) * d2 int skip_iters = @skip int iter = 0 #z = 254.0 loop: complex w2 = w * w complex w3 = w2 * w complex w4 = w2 * w2 w = w - (c2*w4 - c41*w2 + c2) / (4*c2*w3 - 2*c41*w) IF ((abs(cabs(w) - r) < ht) && iter > skip_iters) done = TRUE float wr = real(w) float wi = imag(w) float awr = abs(wr) float awi = abs(wi) IF (awr >= awi) float dist = (awr - d2)*(awr - d2) + (awi - d1)*(awi - d1) float adjust = 1 ELSE dist = (awr - d1)*(awr - d1) + (awi - d2)*(awi - d2) adjust = 0 ENDIF IF (wr >= 0 && wi >= 0) float range_num = 1 - adjust ELSEIF (wr < 0 && wi >= 0) range_num = 2 + adjust ELSEIF (wr < 0 && wi < 0) range_num = 5 - adjust ELSE range_num = 6 + adjust ENDIF float ratio = sqrt(dist / dsqd) #z = 29.0 * ratio + range_num * 30.0 ELSEIF (|w - prev_w| < 1e-5) done = TRUE #z = 251.0 ENDIF iter = iter + 1 prev_w = w bailout: done == FALSE && |w| < 1.0e20 default: title = "FlexBalls Newton Julia 2" maxiter = 3000 param JuliaCoords caption = "Julia Coordinates" default = (0,1) hint = "The Julia set coordinates." endparam param Rm caption = "Ring radius" default = 1.0 hint = "The radius to the midline of the ring." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param HalfT caption = "Half the ring thickness" default = 0.1 hint = "Half the thickness of the ring." endparam } Pokorny_Rings {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float ring_width = @width float index_factor = (colors_in_range - 1) / ring_width int skip_iters = @skip int inter = 0 #z = 254 loop: w = 1.0 / (w * w + c) dist = abs(|w|-.25) IF (dist < ring_width && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Pokorny Rings" maxiter = 5000 param JuliaCoords caption = "Julia Set Coordinates" default = (0.74625,0.05875) hint = "Julia Set Coordinates." endparam param width caption = "Ring Width Factor" default = 2.0 hint = "Controls ring width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } CnFrc_Fnc_Mset {; Paul Carlson init: bool done = FALSE bool first = TRUE complex c = #pixel complex w = 0 float range_num = 0 float max_real = @MaxReal float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi #z = 252 loop: complex prev_w = w complex k = w * w + c w = k - fn1(1.0/ (k+1.0/ (k+1.0/ (k+1.0/ (k+1.0/ (k+1.0)))))) IF (abs(real(w)) > max_real) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE default: title = "Continued Fraction Func Mset" maxiter = 1000 param MaxReal caption = "Max. Value for Real Z" default = 8.0 hint = "Max. Value for Real Z." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } PkyStalksJ2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float stalk_width = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / stalk_width int skip_iters = @skip int iter = 0 #z = 252 loop: w = 1.0 / (w * w + c) IF (abs(real(w)) <= abs(imag(w))) float min_dist = abs(real(w)) ELSE min_dist = abs(imag(w)) ENDIF IF (min_dist < stalk_width && iter > skip_iters) z = index_factor * min_dist + range_num * colors_in_range done= TRUE ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "Pokorny Stalks" maxiter = 500 param width caption = "Width Factor" default = 0.11 hint = "Controls element size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param JuliaCoords caption = "Julia Coordinates" default = (-0.602179463,0.301714302) hint = "The Julia set coordinates." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } PkyStalksM2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = #pixel float range_num = 0 float stalk_width = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / stalk_width int skip_iters = @skip int iter = 0 #z = 252 loop: w = 1.0 / (w * w + c) IF (abs(real(w)) <= abs(imag(w))) float min_dist = abs(real(w)) ELSE min_dist = abs(imag(w)) ENDIF IF (min_dist < stalk_width && iter > skip_iters) z = index_factor * min_dist + range_num * colors_in_range done= TRUE ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "Pokorny Stalks Mandel" maxiter = 500 param width caption = "Width Factor" default = 0.11 hint = "Controls element size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param JuliaCoords caption = "Julia Coordinates" default = (-0.602179463,0.301714302) hint = "The Julia set coordinates." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam switch: type = "PkyStalksJ2" JuliaCoords = #pixel } CosZsqdC_Atan_Mset {; Paul Carlson init: bool done = FALSE bool first = TRUE complex c = #pixel complex prev_w = 0 float range_num = 0 float max_real = @MaxReal float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi #z = 252 loop: complex w = cos(prev_w * prev_w + c) IF (abs(real(w)) > max_real) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF first = FALSE bailout: done == FALSE default: title = "CosZZC Atan Mset" maxiter = 1000 param MaxReal caption = "Max. Value for Real Z" default = 8.0 hint = "Max. Value for Real Z." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Pky2StalksJ2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float stalk_width = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / stalk_width int skip_iters = @skip int iter = 0 #z = 252 loop: w = 1.0 / (w * w + c) w = w * w IF (abs(real(w)) <= abs(imag(w))) float min_dist = abs(real(w)) ELSE min_dist = abs(imag(w)) ENDIF IF (min_dist < stalk_width && iter > skip_iters) z = index_factor * min_dist + range_num * colors_in_range done= TRUE ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "PokornySqd Stalks" maxiter = 500 param width caption = "Width Factor" default = 0.02 hint = "Controls element size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param JuliaCoords caption = "Julia Coordinates" default = (1.063125,0.5235417) hint = "The Julia set coordinates." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } RbAser2J2 {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 int iter = 0 #z = 254 loop: complex w2 = w * w complex w4 = 0.01 * w2 * w2 complex w8 = w4 * w4 complex w12 = w4 * w8 complex w16 = w4 * w12 w = w2 - w4 - w8 - w12 - w16 + c float rsqd = |w| IF (psqd < size && rsqd > size) done = TRUE #z = index_factor * (size - psqd) + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF psqd = rsqd iter = iter + 1 bailout: done == FALSE && |w|<@MaxZ default: title = "Rbs Series Julia" maxiter = 3000 param JuliaCoords caption = "Julia Set Coordinates" default = (3.587297070985906,1.452946845E-7) hint = "Julia Set Coordinates." endparam param width caption = "Width Factor" default = 16 hint = "Controls element size." endparam param MaxZ caption = "Max. value of |z|" default = 16 hint = "Max. value of |z|." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Sin_Atan_Julia {; Paul Carlson init: bool done = FALSE complex c = @JuliaCoords complex prev_w = #pixel float range_num = 0 float max_real = @MaxReal float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi int skip_iters = @skip int iter = 0 #z = 252 loop: complex w = sin(prev_w) + c IF (abs(real(w)) > max_real && iter > skip_iters) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE default: title = "Sin Atan Julia" maxiter = 1000 param JuliaCoords caption = "Julia Set Coordinates" default = (-1.1684406885759,-0.8606881002087681) hint = "Julia Set Coordinates." endparam param MaxReal caption = "Max. Value for Real Z" default = 8.0 hint = "Max. Value for Real Z." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } R4_Mandel {; Paul Carlson init: bool done = FALSE complex w = 0 complex k = (0.5,0.5) complex c = #pixel float size = real(@SizeSkip) float skip = imag(@SizeSkip) float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size float range_num = 0 float iter = 0 #z = 254 loop: w = w * w + c IF (iter > skip) dist = abs(|w - k| - 0.1) IF (dist < size) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 10000 default: title = "Four Rings Mandel" maxiter = 2000 param SizeSkip caption = "Size and Skip" default = (0.2,0) hint = "Ring size and iters to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } MyEqnPlusCStlksJ {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float stalk_width = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / stalk_width float range_num = 0 int skip_iters = @skip int iter = 0 #z = 252 loop: complex w2 = w * w w = c * (1 - w2) / (1 + w2) + c float wr = real(w) float wi = imag(w) IF (abs(wr) <= abs(wi)) float min_dist = abs(wr) ELSE min_dist = abs(wi) ENDIF IF (min_dist < stalk_width && iter > skip_iters) done = TRUE #z = index_factor * min_dist + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.05) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "MyEqnPlusC Stalks Julia" maxiter = 500 param JuliaCoords caption = "Julia Coordinates" default = (0.85625,0.2875) hint = "The Julia set coordinates." endparam param width caption = "Width Factor" default = 0.1 hint = "Controls stalk size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } MyEqn_Func_Julia {; Paul W. Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float dist = 1.0e20 float range_num = 0 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / @size int skip_iters = @skip int iter = 0 #z = 253 loop: complex w2 = w * w w = c * (1 - w2) / (1 + w2) complex a = @multiplier * atan(imag(w) / real(w)) a = a * a + c a = fn1(1 - a) / a dist = abs(|w| - |a|) IF (dist < @size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "MyEqn Func Julia" maxiter = 252 param JuliaCoords caption = "Julia Coordinates" default = (0.15,1.26875) hint = "The Julia set coordinates." endparam param size caption = "Element size" default = 0.3 hint = "Element size." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param multiplier caption = "Angle multiplier" default = 1.0 hint = "Angle multiplier." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Petals_Series_Mset {; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float range_num = 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 num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = colors_in_range / plsqd int skip_iters = @skip iter = 0 #z = 254 loop: complex w2 = w * w complex w4 = 0.01 * w2 * w2 complex w8 = w4 * w4 complex w12 = w4 * w8 complex w16 = w4 * w12 w = w2 - w4 - w8 - w12 - w16 + c IF (iter > skip_iters) 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 (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 IF (done == TRUE ) #z = index_factor * d + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num == num_ranges) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1000 default: title = "Mset Series Petals 1" maxiter = 2000 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 skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } Pky_Petals_Julia {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float r = @size complex ir = flip(r) float r2 = r * r float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = colors_in_range / (r2 + r2) int skip_iters = @skip int iter = 0 #z = 254 loop: w = 1.0 / (w * w + c) bool c1 = (|w - r| < r2) bool c2 = (|w + ir| < r2) bool c3 = (|w + r| < r2) bool c4 = (|w - ir| < r2) IF (c1 && c4) float d = |w - r - ir| ELSEIF (c1 && c2) d = |w - r + ir| ELSEIF (c2 && c3) d = |w + r + ir| ELSEIF (c3 && c4) d = |w + r - ir| ELSE d = -1 ENDIF IF (d > 0 && iter > skip_iters) done = TRUE z = index_factor * d + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Pokorny Petals Julia" maxiter = 2000 param JuliaCoords caption = "Julia Coordinates" default = (-0.602179463,0.301714302) hint = "The Julia set coordinates." endparam param size caption = "Circles radius" default = 0.3 hint = "Controls petal width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } IExpJ2 {; Paul Carlson init: bool done = FALSE complex c = @JuliaCoords complex prev_w = 1.0 / #pixel float range_num = 0 float max_real = @MaxReal float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi #z = 252 loop: complex k = exp(prev_w) complex w = prev_w - (k - c) / k IF (abs(real(w)) > max_real ) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ELSEIF (|w| < 1.0e-10) #z = 252 done = TRUE ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE default: title = "IExpJ2" maxiter = 1000 param JuliaCoords caption = "Julia Set Coordinates" default = (1,0) hint = "Julia Set Coordinates." endparam param MaxReal caption = "Max. Value for Real Z" default = 16.0 hint = "Max. Value for Real Z." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Squiggles_Mandel {; Paul Carlson init: bool done = FALSE complex i = (0,1) complex c = #pixel complex w = 0 float range_num = 0 float size = @width float rad = @Radius float amp = @Amplitude float m = @Multiplier float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size int skip_iters = @skip int iter = 0 #z = 254 loop: w = w * w + c float a = abs(atan(imag(w) / real(w))) float r = rad + amp * rad * sin(m * a) float rw = r * cos(a) float iw = r * sin(a) complex v = rw + i * iw float dist = abs(|w| - |v|) IF (dist < size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Squiggles Mandel" maxiter = 2000 param width caption = "Width Factor" default = 0.03 hint = "Controls element width." endparam param Radius caption = "Circle radius" default = 0.1 hint = "Circle" endparam param Amplitude caption = "Sin wave Amplitude" default = 0.1 hint = "Must be less than 1.0." endparam param Multiplier caption = "Angle multiplier" default = 16.0 hint = "Should be a whole number." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Squiggles_Julia {; Paul Carlson init: bool done = FALSE complex i = (0,1) complex c = @JuliaCoords complex w = #pixel float range_num = 0 float size = @width float rad = @Radius float amp = @Amplitude float m = @Multiplier float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size int skip_iters = @skip int iter = 0 #z = 254 loop: w = w * w + c float a = abs(atan(imag(w) / real(w))) float r = rad + amp * rad * sin(m * a) float rw = r * cos(a) float iw = r * sin(a) complex v = rw + i * iw float dist = abs(|w| - |v|) IF (dist < size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Squiggles Julia" maxiter = 2000 param JuliaCoords caption = "Julia Set Coordinates" default = (0.255,0.0) hint = "Julia Set Coordinates." endparam param width caption = "Width Factor" default = 0.03 hint = "Controls element width." endparam param Radius caption = "Circle radius" default = 0.1 hint = "Circle" endparam param Amplitude caption = "Sin wave Amplitude" default = 0.1 hint = "Must be less than 1.0." endparam param Multiplier caption = "Angle multiplier" default = 16.0 hint = "Should be a whole number." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Blobs_Mandel {; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float range_num = 0 float r = @Radius * 0.4782926234762 float r2 = r * r float icd = 1.12484444888696 * r float ocd = 1.83195123007351 * r float ic0 = 1.59077027517603 * r float oc0 = 2.59077027517603 * r float cen0 = 2.09077027517603 * r float cend = 1.47839783948023 * r complex i = (0.0,1.0) complex c0i = i * ic0 complex c0o = i * oc0 complex c1i = icd + i * icd complex c1o = ocd + i * ocd complex c2i = ic0 complex c2o = oc0 complex c3i = icd - i * icd complex c3o = ocd - i * ocd complex c4i = -c0i complex c4o = -c0o complex c5i = -c1i complex c5o = -c1o complex c6i = -c2i complex c6o = -c2o complex c7i = -c3i complex c7o = -c3o complex c0cen = i * cen0 complex c1cen = cend + i * cend complex c2cen = cen0 complex c3cen = cend - i * cend complex c4cen = -c0cen complex c5cen = -c1cen complex c6cen = -c2cen complex c7cen = -c3cen float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float denom = @multiplier * r int skip_iters = @skip iter = 0 #z = 254 loop: w = w * w + c IF (iter > skip_iters) float wr = real(w) float wi = imag(w) bool c1 = ((|w - c0i| < r2) && (|w - c0o| < r2)) bool c2 = ((|w - c1i| < r2) && (|w - c1o| < r2)) bool c3 = ((|w - c2i| < r2) && (|w - c2o| < r2)) bool c4 = ((|w - c3i| < r2) && (|w - c3o| < r2)) bool c5 = ((|w - c4i| < r2) && (|w - c4o| < r2)) bool c6 = ((|w - c5i| < r2) && (|w - c5o| < r2)) bool c7 = ((|w - c6i| < r2) && (|w - c6o| < r2)) bool c8 = ((|w - c7i| < r2) && (|w - c7o| < r2)) IF (c1) done = TRUE float d = cabs(|w| - |c0cen|) ELSEIF (c2) done = TRUE d = cabs(|w| - |c1cen|) ELSEIF (c3) done = TRUE d = cabs(|w| - |c2cen|) ELSEIF (c4) done = TRUE d = cabs(|w| - |c3cen|) ELSEIF (c5) done = TRUE d = cabs(|w| - |c4cen|) ELSEIF (c6) done = TRUE d = cabs(|w| - |c5cen|) ELSEIF (c7) done = TRUE d = cabs(|w| - |c6cen|) ELSEIF (c8) done = TRUE d = cabs(|w| - |c7cen|) ENDIF ENDIF IF (done == TRUE ) index_factor = (colors_in_range - 1) * (d /denom)^@pow #z = index_factor + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num == num_ranges) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1000 default: title = "Mandel Blobs" maxiter = 2000 param Radius caption = "Circle radius" default = 0.18 hint = "Controls blob width." endparam param pow caption = "Color factor exponent" default = 0.5 hint = "Color factor exponent." endparam param multiplier caption = "Color factor multiplier" default = 0.5 hint = "Color factor multiplier." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Blobs_Julia {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float r = @Radius * 0.4782926234762 float r2 = r * r float icd = 1.12484444888696 * r float ocd = 1.83195123007351 * r float ic0 = 1.59077027517603 * r float oc0 = 2.59077027517603 * r float cen0 = 2.09077027517603 * r float cend = 1.47839783948023 * r complex i = (0.0,1.0) complex c0i = i * ic0 complex c0o = i * oc0 complex c1i = icd + i * icd complex c1o = ocd + i * ocd complex c2i = ic0 complex c2o = oc0 complex c3i = icd - i * icd complex c3o = ocd - i * ocd complex c4i = -c0i complex c4o = -c0o complex c5i = -c1i complex c5o = -c1o complex c6i = -c2i complex c6o = -c2o complex c7i = -c3i complex c7o = -c3o complex c0cen = i * cen0 complex c1cen = cend + i * cend complex c2cen = cen0 complex c3cen = cend - i * cend complex c4cen = -c0cen complex c5cen = -c1cen complex c6cen = -c2cen complex c7cen = -c3cen float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float denom = @multiplier * r int skip_iters = @skip iter = 0 #z = 254 loop: w = w * w + c IF (iter > skip_iters) float wr = real(w) float wi = imag(w) bool c1 = ((|w - c0i| < r2) && (|w - c0o| < r2)) bool c2 = ((|w - c1i| < r2) && (|w - c1o| < r2)) bool c3 = ((|w - c2i| < r2) && (|w - c2o| < r2)) bool c4 = ((|w - c3i| < r2) && (|w - c3o| < r2)) bool c5 = ((|w - c4i| < r2) && (|w - c4o| < r2)) bool c6 = ((|w - c5i| < r2) && (|w - c5o| < r2)) bool c7 = ((|w - c6i| < r2) && (|w - c6o| < r2)) bool c8 = ((|w - c7i| < r2) && (|w - c7o| < r2)) IF (c1) done = TRUE float d = cabs(|w| - |c0cen|) ELSEIF (c2) done = TRUE d = cabs(|w| - |c1cen|) ELSEIF (c3) done = TRUE d = cabs(|w| - |c2cen|) ELSEIF (c4) done = TRUE d = cabs(|w| - |c3cen|) ELSEIF (c5) done = TRUE d = cabs(|w| - |c4cen|) ELSEIF (c6) done = TRUE d = cabs(|w| - |c5cen|) ELSEIF (c7) done = TRUE d = cabs(|w| - |c6cen|) ELSEIF (c8) done = TRUE d = cabs(|w| - |c7cen|) ENDIF ENDIF IF (done == TRUE ) index_factor = (colors_in_range - 1) * (d /denom)^@pow #z = index_factor + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num == num_ranges) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1000 default: title = "Julia Blobs" maxiter = 2000 param JuliaCoords caption = "Julia Coordinates" default = (0.35408308,0.095460802) hint = "The Julia set coordinates." endparam param Radius caption = "Circle radius" default = 0.25 hint = "Controls blob width." endparam param pow caption = "Color factor exponent" default = 0.5 hint = "Color factor exponent." endparam param multiplier caption = "Color factor multiplier" default = 0.5 hint = "Color factor multiplier." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } MyEqn_Julia_Curls {; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float a = @alpha float size = @width float cx = 8.0 * #pi * a float r2 = cx * cx float twopi = #pi + #pi float fourpi = twopi + twopi float sixpi = fourpi + twopi float range_num = 0.0 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) int skip_iters = @skip int bfactor = @Beads int iter = 0 #z = 253 loop: complex w2 = w * w w = c * (1 - w2) / (1 + w2) float rw = real(w) IF (rw >= 0.0 && iter >= skip_iters) float iw = imag(w) float deltax = rw - cx complex v = deltax + flip(iw) float theta = atan2(v) IF (bfactor > 0) float ssize = size * abs(sin(theta * bfactor)) ELSE ssize = size ENDIF float sr = a * theta complex m = cx + sr * exp(flip(theta)) float dist = sqrt(|w - m|) IF (dist < ssize) done = TRUE ENDIF IF (done == FALSE) sr = a * (theta + twopi) m = cx + sr * exp(flip (theta + twopi)) dist = sqrt(|w - m|) IF (dist < ssize) done = TRUE ENDIF ENDIF IF (done == FALSE) sr = a * (theta + fourpi) m = cx + sr * exp(flip (theta + fourpi)) dist = sqrt(|w - m|) IF (dist < ssize) done = TRUE ENDIF ENDIF IF (done == FALSE) sr = a * (theta + sixpi) m = cx + sr * exp(flip (theta + sixpi)) dist = sqrt(|w - m|) IF (dist < ssize) done = TRUE ENDIF ENDIF ENDIF IF (done == TRUE) float factor = (colors_in_range - 1) / ssize #z = factor * dist + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "My Eqn Julia Curls" maxiter = 1000 param alpha caption = "Angle Multiplier" default = 0.3 hint = "Controls spiral size." endparam param width caption = "Width Factor" default = 0.3 hint = "Controls spiral thickness." endparam param Beads caption = "Bead factor" default = -1 hint = "An integer, usualy 5 t0 30" endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param JuliaCoords caption = "Julia Coordinates" default = (-0.058182009,0.675191868) hint = "The Julia set coordinates." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Newt4AtanM2 {; Paul Carlson init: bool done = FALSE complex c = #pixel complex root1 = 1.0 complex root2 = -1.0 complex root3 = sqrt(-c) complex root4 = -root3 complex w = sqrt((1 - c)/6) complex prev_w = w float colors_in_range = @Colors #Z = (253,0) loop: complex w2 = w * w complex w3 = w * w2 complex w4 = w * w3 complex w = w - (w4 + (c-1)*w2 - c)/(4*w3 + 2*(c-1)*w) IF (|w - root1| < @Epsilon) done = TRUE float range_num = 0.0 ELSEIF (|w - root2| < @Epsilon) done = TRUE range_num = 1.0 ELSEIF (|w - root3| < @Epsilon) done = TRUE range_num = 2.0 ELSEIF (|w - root4| < @Epsilon) done = TRUE range_num = 3.0 ENDIF IF (done == TRUE) float ang = atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))/#pi #z = abs(2*(colors_in_range-1)*ang) + colors_in_range*range_num ENDIF prev_w = w bailout: done == FALSE && |w| < 1.0e20 switch: type="Newt4AtanJ2" JuliaCoords=#pixel default: title = "Newton4 Atan Mset 2" maxiter = 1000 param Epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } Newt4AtanJ2 {; Paul Carlson init: bool done = FALSE complex c = @JuliaCoords complex root1 = 1.0 complex root2 = -1.0 complex root3 = sqrt(-c) complex root4 = -root3 complex w = #pixel complex prev_w = w float colors_in_range = @Colors #Z = (253,0) loop: complex w2 = w * w complex w3 = w * w2 complex w4 = w * w3 complex w = w - (w4 + (c-1)*w2 - c)/(4*w3 + 2*(c-1)*w) IF (|w - root1| < @Epsilon) done = TRUE float range_num = 0.0 ELSEIF (|w - root2| < @Epsilon) done = TRUE range_num = 1.0 ELSEIF (|w - root3| < @Epsilon) done = TRUE range_num = 2.0 ELSEIF (|w - root4| < @Epsilon) done = TRUE range_num = 3.0 ENDIF IF (done == TRUE) float ang = atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))/#pi #z = abs(2*(colors_in_range-1)*ang) + colors_in_range*range_num ENDIF prev_w = w bailout: done == FALSE && |w| < 1.0e20 default: title = "Newton4 Atan Julia 2" maxiter = 1000 param JuliaCoords caption = "Julia Coordinates" default = (0.0,0.0) hint = "The Julia set coordinates." endparam param Epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } TbAtanNewt4Mset2 { ; Paul Carlson init: bool done = FALSE float Phi = #pi * 0.125 float Rc = @R float Rm = Rc/sin(Phi); float Py = Rm*sin(Phi+Phi) float Px = Rm*cos(Phi+Phi) float RcSqd = Rc*Rc complex c = #pixel complex root1 = 1.0 complex root2 = -root1 complex root3 = sqrt(-c) complex root4 = -root3 complex c2 = c * c complex cm1 = c - 1 complex tcm1 = cm1 + cm1 complex w = sqrt((1 - c)/6) complex prev_w = w int skip_iters = @skip int iter = 0 #Z = (254,0) loop: complex w2 = w * w complex w3 = w * w2 complex w4 = w2 * w2 complex Err = (w4 + cm1*w2 - c)/(4*w3 + tcm1*w) w = w - Err IF (iter > skip_iters) IF (|w - root1| < @Epsilon) done = TRUE float range_num = 0.0 ELSEIF (|w - root2| < @Epsilon) done = TRUE range_num = 1.0 ELSEIF (|w - root3| < @Epsilon) done = TRUE range_num = 2.0 ELSEIF (|w - root4| < @Epsilon) done = TRUE range_num = 3.0 ENDIF IF (done == TRUE) ang = atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))/#pi #z = abs(58 * ang) + 30 * range_num ELSEIF (abs(cabs(w) - Rm) < Rc) float X = real(w) float Y = imag(w) float Xabs = abs(X) float Yabs = abs(Y) float Dsqd0 = Xabs*Xabs+(Yabs-Rm)*(Yabs-Rm) float Dsqd1 = (Xabs-Px)*(Xabs-Px)+(Yabs-Py)*(Yabs-Py) float Dsqd2 = (Xabs-Rm)*(Xabs-Rm)+Yabs*Yabs IF (Dsqd0 < RcSqd) done = TRUE float ZtoPsqd = Dsqd0 float Circle = 0 ELSEIF (Dsqd1 < RcSqd) done = TRUE ZtoPsqd = Dsqd1 Circle = 1 ELSEIF (Dsqd2 < RcSqd) done = TRUE ZtoPsqd = Dsqd2 Circle = 0 ENDIF IF (done == TRUE) float Ratio = sqrt(ZtoPsqd/Rcsqd) #Z = 29.0 * Ratio + Circle * 30.0 + 120 ENDIF ENDIF ENDIF prev_w = w iter = iter + 1 bailout: done == FALSE default: title = "Tangent Balls and Atan Newton4 Mset 2" maxiter = 3000 param Epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param R caption = "Circle radius" default = 0.2 hint = "The radius of the trap circles." endparam } IExpJ21 { ; Paul Carlson init: bool done = FALSE complex c = @JuliaCoords complex prev_w = 1.0 / #pixel float range_num = 0 float max_real = @MaxReal float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi #z = 252 loop: complex k = exp(prev_w) complex w = prev_w - (k - c) / k IF (abs(real(w)) > max_real ) done = TRUE float delta_i = imag(w) - imag(prev_w) float delta_r = real(w) - real(prev_w) float ang = abs(atan(delta_i / delta_r)) #z = index_factor * ang + range_num * colors_in_range ELSEIF (|w| < 1.0e-10) #z = 252 done = TRUE ENDIF prev_w = w range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF bailout: done == FALSE default: title = "Exp Newton" maxiter = 1000 param JuliaCoords caption = "Julia Set Coordinates" default = (1,0) hint = "Julia Set Coordinates." endparam param MaxReal caption = "Max. Value for Real Z" default = 16.0 hint = "Max. Value for Real Z." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Petals_Halley4_Mset1 { ; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float range_num = 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 num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 2) / plsqd int skip_iters = @skip iter = 0 #z = 254 loop: complex w2 = w * w complex fnc = w2 * w2 - w - c complex der = 4 * w * w2 - 1 complex err = @Relax * fnc / (der - 12 * w2 * fnc / (der + der)) w = w - err IF (iter > skip_iters) 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 (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 IF (done == TRUE ) #z = index_factor * d + range_num * colors_in_range ELSEIF (|err| < 0.000001) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num == num_ranges) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE default: title = "Mset Halley4 Petals" maxiter = 2000 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 Relax caption = "Relaxation factor" default = 1.0 hint = "Relaxation factor." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } Muller3_Atan { ; Paul Carlson init: bool done = FALSE ;The roots of the z^3 - 1 = 0 complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) ;The initial three points on the parabola complex x0 = @m0 * #pixel complex x1 = @m1 * #pixel complex x2 = @m2 * #pixel ;The value of the function at the three points complex f0 = x0^3 - 1 complex f1 = x1^3 - 1 complex f2 = x2^3 - 1 ;The parabolic variables complex h1 = x1 - x0 complex h2 = x2 - x1 complex delta1 = (f1 - f0) / h1 complex delta2 = (f2 - f1) / h2 complex d = (delta2 - delta1) / (h2 - h1) ;Coloring method variables complex prev_p = 0.0 float colors_in_range = @Colors float index_factor = (2.0 * (colors_in_range-1)) / #pi #z = 0 loop: ;Compute a new third point on the parabola f2 = x2^3 - 1 complex b = delta2 + h2 * d complex v = sqrt(b * b - 4.0 * f2 * d) IF (|b - v| < |b + v|) complex w = b + v ELSE w = b - v ENDIF complex h = -2.0 * f2 / w complex p = x2 + h ;The Atan coloring method variables float rp = real(p) float ip = imag(p) float prp = real(prev_p) float pip = imag(prev_p) prev_p = p ;Check if new third point on parabola converges ;to a root IF |p - root1| < @epsilon done = TRUE complex range = 0.0 ELSEIF |p - root2| < @epsilon done = TRUE range = 1.0 ELSEIF |p - root3| < @epsilon done = TRUE range = 2.0 ENDIF IF (done == TRUE) ;We've found a root float idx = abs(atan((ip - pip) / (rp - prp))) * index_factor #z = idx + range * colors_in_range ELSE ;Relocate the parabola x0 = x1 x1 = x2 x2 = p ;Recompute the value of the function at the three points f0 = x0^3 - 1 f1 = x1^3 - 1 f2 = x2^3 - 1 ;Recompute the parabolic variables h1 = x1 - x0 h2 = x2 - x1 delta1 = (f1 - f0) / h1 delta2 = (f2 - f1) / h2 d = (delta2 - delta1) / (h2 - h1) ENDIF bailout: done == FALSE default: title = "Muller3 Atan" maxiter = 1000 param m0 caption = "x0 multiplier" default = 0.1 hint = "x0 multiplier." endparam param m1 caption = "x1 multiplier" default = -0.1 hint = "x1 multiplier." endparam param m2 caption = "x2 multiplier" default = 0.0 hint = "x2 multiplier." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam param epsilon caption = "Epsilon" default = 0.00001 hint = "Distance to root squared." endparam } Newt3_3Way1 { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex prev_w = #pixel complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) float colors_in_range = @Colors float index_factor = (colors_in_range - 1) / @epsilon int skip_iters = @skip int iter = 0 #z = 0 loop: complex w2 = w * w complex w3 = w2 * w w = w - (w3 - 1.0) / (3.0 * w2) float wr = real(w) float wi = imag(w) float pwr = real(prev_w) float pwi = imag(prev_w) prev_w = w IF (iter >= skip_iters) IF (|w - root1| < @epsilon) float range = 0 done = TRUE float dist = @epsilon - |w - root1| ELSEIF (|w - root2| < @epsilon) range = 1 done = TRUE dist = @epsilon - |w - root2| ELSEIF (|w - root3| < @epsilon) range = 2 done = TRUE dist = @epsilon - |w - root3| ENDIF ENDIF IF (done == TRUE) #z = index_factor * dist + range * colors_in_range ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Newton3 3Way" maxiter = 1000 param epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } Newt3_Atan1 { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex prev_w = #pixel complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) float colors_in_range = @Colors float index_factor = (2.0 * (colors_in_range-1)) / #pi int skip_iters = @skip int iter = 0 #z = 0 loop: complex w2 = w * w complex w3 = w2 * w w = w - (w3 - 1.0) / (3.0 * w2) float wr = real(w) float wi = imag(w) float pwr = real(prev_w) float pwi = imag(prev_w) prev_w = w IF (iter >= skip_iters) IF (|w - root1| < @epsilon) float range = 0 done = TRUE ELSEIF (|w - root2| < @epsilon) range = 1 done = TRUE ELSEIF (|w - root3| < @epsilon) range = 2 done = TRUE ENDIF ENDIF IF (done == TRUE) float idx = abs(atan((wi - pwi) / (wr - pwr))) * index_factor #z = idx + range * colors_in_range ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Newton3 Atan" maxiter = 1000 param epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } Newt3_Petals1 { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) float r = @size complex ir = flip(r) float r2 = r * r float colors_in_range = @Colors ;*********** THE NEXT LINE WAS CHANGED ****************** float index_factor = (colors_in_range - 2) / (r2 + r2) #z = 0 loop: complex w2 = w * w complex w3 = w2 * w w = w - (w3 - 1.0) / (3.0 * w2) complex k = w - root1 float range = 0 bool c1 = (|k - r| < r2) bool c2 = (|k + ir| < r2) bool c3 = (|k + r| < r2) bool c4 = (|k - ir| < r2) IF (c1 && c4) done = TRUE float d = |k - r - ir| ELSEIF (c1 && c2) done = TRUE d = |k - r + ir| ELSEIF (c2 && c3) done = TRUE d = |k + r + ir| ELSEIF (c3 && c4) done = TRUE d = |k + r - ir| ENDIF IF (done == FALSE) k = w - root2 range = 1 c1 = (|k - r| < r2) c2 = (|k + ir| < r2) c3 = (|k + r| < r2) c4 = (|k - ir| < r2) IF (c1 && c4) done = TRUE d = |k - r - ir| ELSEIF (c1 && c2) done = TRUE d = |k - r + ir| ELSEIF (c2 && c3) done = TRUE d = |k + r + ir| ELSEIF (c3 && c4) done = TRUE d = |k + r - ir| ENDIF ENDIF IF (done == FALSE) k = w - root3 range = 2 c1 = (|k - r| < r2) c2 = (|k + ir| < r2) c3 = (|k + r| < r2) c4 = (|k - ir| < r2) IF (c1 && c4) done = TRUE d = |k - r - ir| ELSEIF (c1 && c2) done = TRUE d = |k - r + ir| ELSEIF (c2 && c3) done = TRUE d = |k + r + ir| ELSEIF (c3 && c4) done = TRUE d = |k + r - ir| ENDIF ENDIF IF (done == TRUE) #z = index_factor * d + range * colors_in_range ENDIF bailout: done == FALSE && |w| < 1.0e20 default: title = "Newton3 Petals" maxiter = 1000 param size caption = "Petals size factor" default = 0.8 hint = "Petals size factor." endparam param epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } Newt4AtanM21 { ; Copyright (c) Paul Carlson, 1999 init: bool done = FALSE complex c = #pixel complex root1 = 1.0 complex root2 = -1.0 complex root3 = sqrt(-c) complex root4 = -root3 complex w = sqrt((1 - c)/6) complex prev_w = w float colors_in_range = @Colors #Z = (253,0) loop: complex w2 = w * w complex w3 = w * w2 complex w4 = w * w3 complex w = w - (w4 + (c-1)*w2 - c)/(4*w3 + 2*(c-1)*w) IF (|w - root1| < @Epsilon) done = TRUE float range_num = 0.0 ELSEIF (|w - root2| < @Epsilon) done = TRUE range_num = 1.0 ELSEIF (|w - root3| < @Epsilon) done = TRUE range_num = 2.0 ELSEIF (|w - root4| < @Epsilon) done = TRUE range_num = 3.0 ENDIF IF (done == TRUE) ang = atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))/#pi #z = abs(2*(colors_in_range-1)*ang) + colors_in_range*range_num ENDIF prev_w = w bailout: done == FALSE && |w| < 1.0e20 default: title = "Newton4 Atan 2" maxiter = 1000 param Epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } popcorn_balls { ; Paul Carlson init: bool done = FALSE complex prev_w = #pixel float x = real(#pixel) float y = imag(#pixel) float h = @Hval float max_r = @Radius float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / max_r float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: float prev_x = x x = x - h * sin(y + tan(3 * y)) y = y - h * sin(prev_x + tan(3 * prev_x)) complex w = x + flip(y) float r = |prev_w| / |w| prev_w = w IF (r < max_r && iter > skip_iters) done = TRUE #z = index_factor * r + range_num * colors_in_range ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < @MaxW default: title = "Popcorn Balls" maxiter = 1000 param Radius caption = "Ball radius factor" default = 1.0 hint = "Controls ball size." endparam param Hval caption = "h value" default = 0.1 hint = "Popcorn h value." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param MaxW caption = "Maximum |z|" default = 4.0 hint = "Maximum |z|." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } RectMandel { ; Paul Carlson init: bool done = FALSE bool in_top = FALSE bool in_bot = FALSE bool in_left = FALSE bool in_right = FALSE complex w = 0.0 complex c = #pixel float range = 0 float halfh = @Height * 0.5 float halfw = @Width * 0.5 float sizev = @VerSize float sizeh = @HorSize int skip_iters = @skip int iter = 0 #z = 252 loop: w = w * w + c IF (iter >= skip_iters) float rw = real(w) float iw = imag(w) ;Check top float top_dist = abs(halfh - iw) IF (top_dist <= sizeh) IF ((halfw + sizev - abs(rw)) >= 0) in_top = TRUE done = TRUE ENDIF ;Check bottom ELSE float bot_dist = abs(halfh + iw) IF (bot_dist <= sizeh) IF ((halfw + sizev - abs(rw)) >= 0) in_bot = TRUE done = TRUE ENDIF ENDIF ENDIF ;Check right float right_dist = abs(halfw - rw) IF (right_dist <= sizev) IF ((halfh + sizeh - abs(iw)) >= 0) in_right = TRUE done = TRUE ENDIF ;Check left ELSE float left_dist = abs(halfh + rw) IF (left_dist <= sizev) IF ((halfh + sizeh - abs(iw)) >= 0) in_left = TRUE done = TRUE ENDIF ENDIF ENDIF IF (done == TRUE) IF (in_top) dist = top_dist float size = sizeh range = 0 IF (in_left && left_dist < top_dist) dist = left_dist size = sizev range = 1 ENDIF IF (in_right && right_dist < top_dist) dist = right_dist size = sizev range = 1 ENDIF ELSE IF (in_bot) dist = bot_dist size = sizeh range = 0 IF (in_left && left_dist < bot_dist) dist = left_dist size = sizev range = 1 ENDIF IF (in_right && right_dist < bot_dist) dist = right_dist size = sizev range = 1 ENDIF ENDIF ENDIF IF (in_right) dist = right_dist size = sizev range = 1 IF (in_top && top_dist < right_dist) dist = top_dist size = sizeh range = 0 ENDIF IF (in_bot && bot_dist < right_dist) dist = bot_dist size = sizeh range = 0 ENDIF ELSE IF (in_left) dist = left_dist size = sizev range = 1 IF (in_top && top_dist < left_dist) dist = top_dist size = sizeh range = 0 ENDIF IF (in_bot && bot_dist < left_dist) dist = bot_dist size = sizeh range = 0 ENDIF ENDIF ENDIF z = 124.0 * dist / size + range * 125.0 ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "Rectangles Mandel" maxiter = 500 param Width caption = "Rectangle width" default = 2.0 hint = "Rectangle width." endparam param Height caption = "Rectangle height" default = 2.0 hint = "Rectangle height." endparam param VerSize caption = "Size of vertical side" default = 0.1 hint = "Size of vertical side." endparam param HorSize caption = "Size of horizontal side" default = 0.1 hint = "Size of horizontal side." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam } Petals_Halley4_Mset { ; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float range_num = 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 num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 2) / plsqd int skip_iters = @skip iter = 0 #z = 254 loop: complex w2 = w * w complex fnc = w2 * w2 - w - c complex der = 4 * w * w2 - 1 complex err = @Relax * fnc / (der - 12 * w2 * fnc / (der + der)) w = w - err IF (iter > skip_iters) 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 (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 IF (done == TRUE ) #z = index_factor * d + range_num * colors_in_range ELSEIF (|err| < 0.000001) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num == num_ranges) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE default: title = "Petals Halley4 Mset" maxiter = 2000 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 Relax caption = "Relaxation factor" default = 1.0 hint = "Relaxation factor." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } Newt3_3Way { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex prev_w = #pixel complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) float colors_in_range = @Colors float index_factor = (colors_in_range - 1) / @epsilon int skip_iters = @skip int iter = 0 #z = 0 loop: complex w2 = w * w complex w3 = w2 * w w = w - (w3 - 1.0) / (3.0 * w2) float wr = real(w) float wi = imag(w) float pwr = real(prev_w) float pwi = imag(prev_w) prev_w = w IF (iter >= skip_iters) IF (|w - root1| < @epsilon) float range = 0 done = TRUE float dist = @epsilon - |w - root1| ELSEIF (|w - root2| < @epsilon) range = 1 done = TRUE dist = @epsilon - |w - root2| ELSEIF (|w - root3| < @epsilon) range = 2 done = TRUE dist = @epsilon - |w - root3| ENDIF ENDIF IF (done == TRUE) #z = index_factor * dist + range * colors_in_range ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Newt3 3Way" maxiter = 1000 param epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } Newt3_Atan { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex prev_w = #pixel complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) float colors_in_range = @Colors float index_factor = (2.0 * (colors_in_range-1)) / #pi int skip_iters = @skip int iter = 0 #z = 0 loop: complex w2 = w * w complex w3 = w2 * w w = w - (w3 - 1.0) / (3.0 * w2) float wr = real(w) float wi = imag(w) float pwr = real(prev_w) float pwi = imag(prev_w) prev_w = w IF (iter >= skip_iters) IF (|w - root1| < @epsilon) float range = 0 done = TRUE ELSEIF (|w - root2| < @epsilon) range = 1 done = TRUE ELSEIF (|w - root3| < @epsilon) range = 2 done = TRUE ENDIF ENDIF IF (done == TRUE) float idx = abs(atan((wi - pwi) / (wr - pwr))) * index_factor #z = idx + range * colors_in_range ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Newt3 Atan" maxiter = 1000 param epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } Newt3_Petals { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) float r = @size complex ir = flip(r) float r2 = r * r float colors_in_range = @Colors float index_factor = colors_in_range / (r2 + r2) #z = 0 loop: complex w2 = w * w complex w3 = w2 * w w = w - (w3 - 1.0) / (3.0 * w2) complex k = w - root1 float range = 0 bool c1 = (|k - r| < r2) bool c2 = (|k + ir| < r2) bool c3 = (|k + r| < r2) bool c4 = (|k - ir| < r2) IF (c1 && c4) done = TRUE float d = |k - r - ir| ELSEIF (c1 && c2) done = TRUE d = |k - r + ir| ELSEIF (c2 && c3) done = TRUE d = |k + r + ir| ELSEIF (c3 && c4) done = TRUE d = |k + r - ir| ENDIF IF (done == FALSE) k = w - root2 range = 1 c1 = (|k - r| < r2) c2 = (|k + ir| < r2) c3 = (|k + r| < r2) c4 = (|k - ir| < r2) IF (c1 && c4) done = TRUE d = |k - r - ir| ELSEIF (c1 && c2) done = TRUE d = |k - r + ir| ELSEIF (c2 && c3) done = TRUE d = |k + r + ir| ELSEIF (c3 && c4) done = TRUE d = |k + r - ir| ENDIF ENDIF IF (done == FALSE) k = w - root3 range = 2 c1 = (|k - r| < r2) c2 = (|k + ir| < r2) c3 = (|k + r| < r2) c4 = (|k - ir| < r2) IF (c1 && c4) done = TRUE d = |k - r - ir| ELSEIF (c1 && c2) done = TRUE d = |k - r + ir| ELSEIF (c2 && c3) done = TRUE d = |k + r + ir| ELSEIF (c3 && c4) done = TRUE d = |k + r - ir| ENDIF ENDIF IF (done == TRUE) #z = index_factor * d + range * colors_in_range ENDIF bailout: done == FALSE && |w| < 1.0e20 default: title = "Newt3 Petals" maxiter = 1000 param size caption = "Petals size factor" default = 0.8 hint = "Petals size factor." endparam param epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam } MyEqn_Jul { init: complex #z = #pixel complex c = @JuliaCoords loop: complex z2 = z * z #z = c * (1 - z2) / (1 + z2) bailout: |#z| < 16.0 default: title="MyEqn Jul" } MyEqn_Mset { init: complex #z = 0.0 complex c = #pixel loop: complex z2 = z * z #z = c * (1 - z2) / (1 + z2) bailout: |#z| < 16.0 switch: type="MyEqn_Jul" JuliaCoords=#pixel default: title="MyEqn Mset" } Curry_Rings_Mset { ; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float range_num = 0 float ring_width = @width float index_factor = (colors_in_range - 1) / ring_width int skip_iters = @skip int iter = 0 #z = 251 loop: complex w2 = w * w complex a = @Relax * (w*w2 + (c-1)*w-c) / (3*w2 + c - 1) w = w - a dist = abs(|w|-.25) IF (dist < ring_width && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (|a| < 0.000001) done = TRUE IF (iter % 2 == 0) #z = 254 ELSE #z = 253 ENDIF ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0.0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Curry Rings Mset" maxiter = 5000 param width caption = "Ring Width Factor" default = 2.0 hint = "Controls ring width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param Relax caption = "Relaxation factor" default = 1.0 hint = "Relaxation factor." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } Petals_Triplets_Mandel { ; Paul Carlson init: ;Should the radial petals point in or out? IF @Reverse == FALSE float f = 1.0 ;In ELSE f = -1.0 ;Out ENDIF bool done = FALSE complex w = 0 complex c = #pixel float r = @Radius float r2 = r * r float rs30 = 0.5 * r ; r * sin(30 degrees) float rc30 = 0.886025403784438 * r ; r * cos(30 degrees) float hrs30 = 0.5 * rs30 float hrc30 = 0.5 * rc30 float frs30 = f * rs30 float fhrs30 = f * hrs30 ;The centers of the four triplets complex cen123 = r + @Offset complex cen456 = -flip(cen123) complex cen789 = -cen123 complex cenabc = flip(cen123) ;The circle centers of triplet 1 complex cc1 = cen123 - frs30 - flip(rc30) complex cc2 = cen123 - frs30 + flip(rc30) complex cc3 = cen123 + f * r ;The circle centers of triplet 2 complex cc4 = cen456 - rc30 + flip(frs30) complex cc5 = cen456 + rc30 + flip(frs30) complex cc6 = cen456 - f * flip(r) ;The circle centers of triplet 3 complex cc7 = cen789 + frs30 + flip(rc30) complex cc8 = cen789 + frs30 - flip(rc30) complex cc9 = cen789 - f * r ;The circle centers of triplet 4 complex cca = cenabc + rc30 - flip(frs30) complex ccb = cenabc - rc30 - flip(frs30) complex ccc = cenabc + f * flip(r) ;The petal centers of triple 1 complex cp1 = cen123 - frs30 complex cp2 = cen123 + fhrs30 + flip(hrc30) complex cp3 = cen123 + fhrs30 - flip(hrc30) ;The petal centers of triplet 2 complex cp4 = cen456 + flip(frs30) complex cp5 = cen456 + hrc30 - flip(fhrs30) complex cp6 = cen456 - hrc30 - flip(fhrs30) ;The petal centers of triplet 3 complex cp7 = cen789 + frs30 complex cp8 = cen789 - fhrs30 - flip(hrc30) complex cp9 = cen789 - fhrs30 + flip(hrc30) ;The petal centers of triplet 4 complex cpa = cenabc - flip(frs30) complex cpb = cenabc - hrc30 + flip(fhrs30) complex cpc = cenabc + hrc30 + flip(fhrs30) float range_num = 0 float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / (0.5 * r) int skip_iters = @skip iter = 0 #z = 254 loop: w = w * w + c IF (iter > skip_iters) ;Each petal trap is the overlap of two circles IF (|w - cc1| <= r2 && |w - cc2| <= r2) ;Petal 1 done = TRUE float d = |w - cp1| ELSEIF (|w - cc2| <= r2 && |w - cc3| <= r2) ;Petal 2 done = TRUE d = |w - cp2| ELSEIF (|w - cc1| <= r2 && |w - cc3| <= r2) ;Petal 3 done = TRUE d = |w - cp3| ELSEIF (|w - cc4| <= r2 && |w - cc5| <= r2) ;Petal 4 done = TRUE d = |w - cp4| ELSEIF (|w - cc5| <= r2 && |w - cc6| <= r2) ;Petal 5 done = TRUE d = |w - cp5| ELSEIF (|w - cc4| <= r2 && |w - cc6| <= r2) ;Petal 6 done = TRUE d = |w - cp6| ELSEIF (|w - cc7| <= r2 && |w - cc8| <= r2) ;Petal 7 done = TRUE d = |w - cp7| ELSEIF (|w - cc8| <= r2 && |w - cc9| <= r2) ;Petal 8 done = TRUE d = |w - cp8| ELSEIF (|w - cc7| <= r2 && |w - cc9| <= r2) ;Petal 9 done = TRUE d = |w - cp9| ELSEIF (|w - cca| <= r2 && |w - ccb| <= r2) ;Petal a done = TRUE d = |w - cpa| ELSEIF (|w - ccb| <= r2 && |w - ccc| <= r2) ;Petal b done = TRUE d = |w - cpb| ELSEIF (|w - cca| <= r2 && |w - ccc| <= r2) ;Petal c done = TRUE d = |w - cpc| ENDIF ENDIF IF (done == TRUE ) #z = index_factor * sqrt(d) + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num == num_ranges) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1000 default: title = "Petals Triplets Mandel" maxiter = 2000 param Reverse caption = "Reverse triplets flag" default = FALSE hint = "no makes radial petal point in, yes out" endparam param Radius caption = "Circles radius" default = 0.18 hint = "Controls petal width." endparam param Offset caption = "Triplets offset" default = 0.05 hint = "Distance from origin to edge of triplet." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } PWC_Eqn_Mset { ; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: complex prev_w = w complex w2 = w * w w = (w * w + c) * (1 - w2) / (1 + w2) IF (abs(real(w)) > size && iter >= skip_iters) done = TRUE float angle = abs(atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))) #z = index_factor * angle + range_num * colors_in_range ELSE IF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE default: title = "PWC Eqn Mset" maxiter = 500 param width caption = "Max. value of abs(real(z))" default = 2.0 hint = "Max. value of abs(real(z))." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } PWC2_Eqn_Mset { ; Paul Carlson init: bool done = FALSE complex w = 0 complex c = #pixel float size = @width float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = 2 * colors_in_range / #pi float range_num = 0 int skip_iters = @skip int iter = 0 #z = 254 loop: complex prev_w = w complex w2 = w * w w = (w * w + c) * (1 - w2) / (1 + w2) + c IF (abs(real(w)) > size && iter >= skip_iters) done = TRUE float angle = abs(atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))) #z = index_factor * angle + range_num * colors_in_range ELSE IF (iter == #maxiter - 2) done = TRUE #z = 251 ENDIF ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE default: title = "PWC2 Eqn Mset" maxiter = 500 param width caption = "Max. value of abs(real(z))" default = 2.0 hint = "Max. value of abs(real(z))." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (8,30) hint = "# co color ranges and # of colors in range." endparam } Rainbow_Julia_Curls { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float a = @alpha float size = @width float cx = 8.0 * #pi * a float r2 = cx * cx float twopi = #pi + #pi float fourpi = twopi + twopi float sixpi = fourpi + twopi float pf1 = #pi / 4.0 float pf2 = pf1 + pf1 float pf3 = pf2 + pf1 float pf4 = pf3 + pf1 float colors_in_range = @Colors int skip_iters = @skip int iter = 0 #z = 253 loop: complex w2 = w * w w = c * (1 - w2) / (1 + w2) float rw = real(w) IF (rw >= 0.0 && iter >= skip_iters) float iw = imag(w) float deltax = rw - cx complex v = deltax + flip(iw) float theta = atan2(v) float ssize = size * abs(sin(theta * 4.0)) float sr = a * theta complex m = cx + sr * exp(flip(theta)) IF (theta < -pf3) range_num = 0.0 ELSEIF (theta < -pf2) range_num = 1.0 ELSEIF (theta < -pf1) range_num = 2.0 ELSEIF (theta < 0.0) range_num = 3.0 ELSEIF (theta < pf2) range_num = 4.0 ELSEIF (theta < pf3) range_num = 5.0 ELSEIF (theta < pf4) range_num = 6.0 ELSE range_num = 7.0 ENDIF float dist = sqrt(|w - m|) IF (dist < ssize) done = TRUE ENDIF IF (done == FALSE) sr = a * (theta + twopi) m = cx + sr * exp(flip (theta + twopi)) dist = sqrt(|w - m|) IF (dist < ssize) done = TRUE ENDIF ENDIF IF (done == FALSE) sr = a * (theta + fourpi) m = cx + sr * exp(flip (theta + fourpi)) dist = sqrt(|w - m|) IF (dist < ssize) done = TRUE ENDIF ENDIF IF (done == FALSE) sr = a * (theta + sixpi) m = cx + sr * exp(flip (theta + sixpi)) dist = sqrt(|w - m|) IF (dist < ssize) done = TRUE ENDIF ENDIF ENDIF IF (done == TRUE) float factor = (colors_in_range - 1) / ssize #z = factor * dist + range_num * colors_in_range ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Rainbow Julia Curls" maxiter = 1000 param alpha caption = "Angle Multiplier" default = 0.3 hint = "Controls spiral size." endparam param width caption = "Width Factor" default = 0.3 hint = "Controls spiral thickness." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam param JuliaCoords caption = "Julia Coordinates" default = (-0.058182009,0.675191868) hint = "The Julia set coordinates." endparam param Colors caption = "Colors in range" default = 30 hint = "# of colors in range." endparam } Secant3_Atan { ; Paul Carlson init: bool done = FALSE ;The roots of the z^3 - 1 = 0 complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) ;The initial two points complex x0 = @m0 * #pixel complex x1 = @m1 * #pixel ;The value of the function at the two points complex f0 = x0^3 - 1 complex f1 = x1^3 - 1 ;Coloring method variables complex prev_p = 0.0 float colors_in_range = @Colors float index_factor = (2.0 * (colors_in_range-1)) / #pi #z = 254.0 loop: ;Compute a new second point complex p = x1 - @relax * f1 * (x1 - x0) / (f1 - f0) ;The Atan coloring method variables float rp = real(p) float ip = imag(p) float prp = real(prev_p) float pip = imag(prev_p) prev_p = p ;Check if new second point converges to a root IF |p - root1| < @epsilon done = TRUE complex range = 0.0 ELSEIF |p - root2| < @epsilon done = TRUE range = 1.0 ELSEIF |p - root3| < @epsilon done = TRUE range = 2.0 ENDIF IF (done == TRUE) ;We've found a root float idx = abs(atan((ip - pip) / (rp - prp))) * index_factor #z = idx + range * colors_in_range ELSE ;Update the points and functions x0 = x1 x1 = p f0 = f1 f1 = p^3 - 1.0 ENDIF bailout: done == FALSE default: title = "Secant3 Atan" maxiter = 1000 param m0 caption = "x0 multiplier" default = 0.1 hint = "x0 multiplier." endparam param m1 caption = "x1 multiplier" default = -0.1 hint = "x1 multiplier." endparam param relax caption = "Relaxation factor" default = 1.0 hint = "Relaxation factor." endparam param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam param epsilon caption = "Epsilon" default = 0.00001 hint = "Distance to root squared." endparam } Spir2_Trunc_Enhanced { ; Paul Carlson init: bool done = FALSE w = #pixel c = @JuliaCoords range_num = 0 stalk_width = @Width max_wm = @MaxModW num_ranges = real(@RangesColors) colors_in_range = imag(@RangesColors) index_factor = (colors_in_range - 1) / stalk_width skip_iters = @Skip iter = 0 #z = 253 loop: ;The equations we're iterating w = w * w - c wr = real(w) awr = abs(wr) w = w - wr + awr ;The usual stalk stuff... awr = abs(real(w)) awi = abs(imag(w)) IF (awr <= awi) dist = awr ELSE dist = awi ENDIF ; ...but we truncate the stalks when |w| >= max_wm IF (dist < stalk_width && |w| < max_wm && iter > skip_iters) #z = index_factor * dist + range_num * colors_in_range done = TRUE ENDIF ;Cycle thru the color ranges range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < @MaxZ default: title = "Spiral 2 Truncated Enhanced" maxiter = 5000 param JuliaCoords caption = "Julia Coordinates" default = (0.1855469,0.649882825) hint = "The Julia set coordinates." endparam param Width caption = "Stalk Width" default = 0.1 hint = "Controls stalk width." endparam param MaxModW caption = "Maximum |W|" default = 1.0 hint = "Controls stalk length." endparam param Skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param MaxZ caption = "Maximum |Z|" default = 4.0 hint = "Maximum |Z|for bailout" endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } SymmFuncAng2 { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range_num = 0 float size = @width float k = @multiplier float num_ranges = real(@RangesColors) float colors_in_range = imag(@RangesColors) float index_factor = (colors_in_range - 1) / size int skip_iters = @skip int iter = 0 #z = 254 loop: w = sqr(c / (c - abs((w - 1) / w))) complex a = k * atan(imag(w) / real(w)) a = a * a + c complex v = fn1(1.0 - a) / a float dist = abs(|w| - |v|) IF (dist < size && iter > skip_iters) done = TRUE #z = index_factor * dist + range_num * colors_in_range ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF range_num = range_num + 1 IF (range_num > num_ranges - 0.5) range_num = 0 ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e20 default: title = "Symmetry Func Angle 2" maxiter = 500 param JuliaCoords caption = "Julia Set Coordinates" default = (1,-0.5) hint = "Julia Set Coordinates." endparam param width caption = "Width Factor" default = 0.03 hint = "Controls element width." endparam param multiplier caption = "Angle multiplier" default = 1.0 hint = "Angle multiplier." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param RangesColors caption = "Ranges and Colors" default = (2,125) hint = "# co color ranges and # of colors in range." endparam } TbAtanNewtMset3 { ; Paul Carlson init: bool done = FALSE float Phi = #pi * 0.125 float Rc = real(@R) float Rm = Rc/sin(Phi); float Py = Rm*sin(Phi+Phi) float Px = Rm*cos(Phi+Phi) float RcSqd = Rc*Rc complex c = #pixel complex c1 = 1.0 / c complex root1 = c1 complex root2 = -root1 complex root3 = c complex root4 = -root3 complex c2 = c * c complex c41 = c2 * c2 + 1 complex w = sqrt(c41 / (6*c2)) complex prev_w = w int skip_iters = @skip int iter = 0 #Z = (250,0) loop: complex w2 = w * w complex w4 = w2 * w2 complex Err = (c2*w4 - c41*w2 + c2) / (4*c2*w2*w - 2*c41*w) w = w - Err IF (iter > skip_iters) IF (|w - root1| < @Epsilon) done = TRUE float range_num = 0.0 ELSEIF (|w - root2| < @Epsilon) done = TRUE range_num = 1.0 ELSEIF (|w - root3| < @Epsilon) done = TRUE range_num = 2.0 ELSEIF (|w - root4| < @Epsilon) done = TRUE range_num = 3.0 ENDIF IF (done == TRUE) ang = atan((imag(w)-imag(prev_w))/(real(w)-real(prev_w)))/#pi #z = abs(58 * ang) + 30 * range_num ELSEIF (abs(cabs(w) - Rm) < Rc) float X = real(w) float Y = imag(w) float Xabs = abs(X) float Yabs = abs(Y) float Dsqd0 = Xabs*Xabs+(Yabs-Rm)*(Yabs-Rm) float Dsqd1 = (Xabs-Px)*(Xabs-Px)+(Yabs-Py)*(Yabs-Py) float Dsqd2 = (Xabs-Rm)*(Xabs-Rm)+Yabs*Yabs IF (Dsqd0 < RcSqd) done = TRUE float ZtoPsqd = Dsqd0 float Circle = 0 ELSEIF (Dsqd1 < RcSqd) done = TRUE ZtoPsqd = Dsqd1 Circle = 1 ELSEIF (Dsqd2 < RcSqd) done = TRUE ZtoPsqd = Dsqd2 Circle = 0 ENDIF IF (done == TRUE) float Ratio = sqrt(ZtoPsqd/Rcsqd) #Z = 29.0 * Ratio + Circle * 30.0 + 120 ENDIF ENDIF ENDIF prev_w = w iter = iter + 1 bailout: done == FALSE default: title = "Tangent Balls and Atan Newton Mset 3" maxiter = 3000 param Epsilon caption = "Epsilon" default = 0.1 hint = "Distance to root squared." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip." endparam param R caption = "Circle radius" default = 0.2 hint = "The radius of the trap circles." endparam } Steff3_Atan { ; Paul Carlson init: bool done = FALSE ;The roots of the z^3 - 1 = 0 complex root1 = (1,0) complex root2 = (-0.5,0.866025403) complex root3 = (-0.5,-0.866025403) ;The initial approximation complex pt0 = #pixel ;Coloring method variables complex prev_p = 0.0 float colors_in_range = @Colors float index_factor = (2.0 * (colors_in_range - 1)) / #pi #z = 254.0 loop: ;Compute the next approximation complex pt1 = 1.0 / sqr(pt0) complex pt2 = 1.0 / sqr(pt1) complex p = pt0 - (pt1 - pt0) * (pt1 - pt0) / (pt2 - pt1 - pt1 + pt0) ;The Atan coloring method variables float rp = real(p) float ip = imag(p) float prp = real(prev_p) float pip = imag(prev_p) prev_p = p ;Check if we have converged to a root IF |p - root1| < @epsilon done = TRUE complex range = 0.0 ELSEIF |p - root2| < @epsilon done = TRUE range = 1.0 ELSEIF |p - root3| < @epsilon done = TRUE range = 2.0 ENDIF IF (done == TRUE) ;We've found a root float idx = abs(atan((ip - pip) / (rp - prp))) * index_factor #z = idx + range * colors_in_range ELSE ;Update the approximation pt0 = p ENDIF bailout: done == FALSE default: title = "Steff3 Atan" maxiter = 1000 param Colors caption = "Colors in range" default = 60 hint = "Number of colors in range." endparam param epsilon caption = "Epsilon" default = 0.00001 hint = "Distance to root squared." endparam } StarOfDavidNspir { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range = 0 float size = @Width float r = @Radius float halfside = 1.73205080756888 * r int skip_iters = @skip int iter = 0 #z = 252 loop: w = sqr(w) wr = real(w) awr = abs(wr) w = w - wr + awr - c IF (iter >= skip_iters) ;Compute all the distances float rw = real(w) float iw = imag(w) float d2 = abs(iw + r) float d4 = abs(iw - r) float d1 = abs( 0.866025403784439 * rw + 0.5 * iw - r) float d3 = abs(-0.866025403784439 * rw + 0.5 * iw - r) float d5 = abs( 0.866025403784439 * rw - 0.5 * iw - r) float d6 = abs(-0.866025403784439 * rw - 0.5 * iw - r) ;Check line 1 IF (d1 < size) range = 0 IF (d2 < size) done = TRUE IF (d1 <= d2) float dist = d1 IF (iw <= -r) dist = d2 ENDIF ELSE dist = d2 IF (rw >= halfside) dist = d1 ENDIF ENDIF ELSEIF (d3 < size) done = TRUE IF (d1 <= d3) dist = d1 IF (rw <= 0.0) dist = d3 ENDIF ELSE dist = d3 IF (rw > 0.0) dist = d1 ENDIF ENDIF ELSEIF (d4 < size) done = TRUE IF (d1 <= d4) dist = d1 ELSE dist = d4 range = 1 ENDIF ELSEIF (d5 < size) done = TRUE IF (d1 <= d5) dist = d1 ELSE dist = d5 range = 1 ENDIF ELSEIF (rw >= 0.0 && iw >= -r) done = TRUE dist = d1 ENDIF ENDIF ;Check line 2 IF (d2 < size && done == FALSE) range = 0 IF (d3 < size) done = TRUE IF (d2 <= d3) dist = d2 IF (rw <= -halfside) dist = d3 ENDIF ELSE dist = d3 IF (iw <= -r) dist = d2 ENDIF ENDIF ELSEIF (d5 < size) done = TRUE IF (d2 <= d5) dist = d2 ELSE dist = d5 range = 1 ENDIF ELSEIF (d6 < size) done = TRUE IF (d2 <= d6) dist = d2 ELSE dist = d6 range = 1 ENDIF ELSEIF (abs(rw) <= halfside) done = TRUE dist = d2 ENDIF ENDIF ;Check line 3 IF (d3 < size && done == FALSE) range = 0 IF (d4 < size) done = TRUE IF (d3 <= d4) dist = d3 ELSE dist = d4 range = 1 ENDIF ELSEIF (d6 < size) done = TRUE IF (d3 <= d6) dist = d3 ELSE dist = d6 range = 1 ENDIF ELSEIF (rw <= 0.0 && iw >= -r) done = TRUE dist = d3 ENDIF ENDIF ;Check line 4 IF (d4 < size && done == FALSE) range = 1 IF (d5 < size) done = TRUE IF (d4 <= d5) dist = d4 IF (rw >= halfside) dist = d5 ENDIF ELSE dist = d5 IF (iw >= r) dist = d4 ENDIF ENDIF ELSEIF (d6 < size) done = TRUE IF (d4 <= d6) dist = d4 IF (rw <= -halfside) dist = d6 ENDIF ELSE dist = d6 IF (iw >= r) dist = d4 ENDIF ENDIF ELSEIF (abs(rw) <= halfside) done = TRUE dist = d4 ENDIF ENDIF ;Check line 5 IF (d5 < size && done == FALSE) range = 1 IF (d6 < size) done = TRUE IF (d5 <= d6) dist = d5 IF (rw <= 0.0) dist = d6 ENDIF ELSE dist = d6 IF (rw > 0.0) dist = d5 ENDIF ENDIF ELSEIF (rw >= 0.0 && iw <= r) done = TRUE dist = d5 ENDIF ENDIF ;Check line 6 IF (d6 < size && done == FALSE) range = 1 IF (rw <= 0.0 && iw <= r) done = TRUE dist = d6 ENDIF ENDIF IF (done == TRUE) z = 124.0 * dist / size + range * 125.0 ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "Star Of David Nspir" maxiter = 2000 param JuliaCoords caption = "Julia Coordinates" default = (1.75,0.0) hint = "The Julia set coordinates." endparam param Radius caption = "Radius of inscribed circle" default = 0.1 hint = "Controls size of star." endparam param Width caption = "Element width" default = 0.02 hint = "Controls element width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam } StarOfDavidMandel { ; Paul Carlson init: bool done = FALSE complex w = 0.0 complex c = #pixel float range = 0 float size = @Width float r = @Radius float halfside = 1.73205080756888 * r int skip_iters = @skip int iter = 0 #z = 252 loop: w = w * w + c IF (iter >= skip_iters) ;Compute all the distances float rw = real(w) float iw = imag(w) float d2 = abs(iw + r) float d4 = abs(iw - r) float d1 = abs( 0.866025403784439 * rw + 0.5 * iw - r) float d3 = abs(-0.866025403784439 * rw + 0.5 * iw - r) float d5 = abs( 0.866025403784439 * rw - 0.5 * iw - r) float d6 = abs(-0.866025403784439 * rw - 0.5 * iw - r) ;Check line 1 IF (d1 < size) range = 0 IF (d2 < size) done = TRUE IF (d1 <= d2) float dist = d1 IF (iw <= -r) dist = d2 ENDIF ELSE dist = d2 IF (rw >= halfside) dist = d1 ENDIF ENDIF ELSEIF (d3 < size) done = TRUE IF (d1 <= d3) dist = d1 IF (rw <= 0.0) dist = d3 ENDIF ELSE dist = d3 IF (rw > 0.0) dist = d1 ENDIF ENDIF ELSEIF (d4 < size) done = TRUE IF (d1 <= d4) dist = d1 ELSE dist = d4 range = 1 ENDIF ELSEIF (d5 < size) done = TRUE IF (d1 <= d5) dist = d1 ELSE dist = d5 range = 1 ENDIF ELSEIF (rw >= 0.0 && iw >= -r) done = TRUE dist = d1 ENDIF ENDIF ;Check line 2 IF (d2 < size && done == FALSE) range = 0 IF (d3 < size) done = TRUE IF (d2 <= d3) dist = d2 IF (rw <= -halfside) dist = d3 ENDIF ELSE dist = d3 IF (iw <= -r) dist = d2 ENDIF ENDIF ELSEIF (d5 < size) done = TRUE IF (d2 <= d5) dist = d2 ELSE dist = d5 range = 1 ENDIF ELSEIF (d6 < size) done = TRUE IF (d2 <= d6) dist = d2 ELSE dist = d6 range = 1 ENDIF ELSEIF (abs(rw) <= halfside) done = TRUE dist = d2 ENDIF ENDIF ;Check line 3 IF (d3 < size && done == FALSE) range = 0 IF (d4 < size) done = TRUE IF (d3 <= d4) dist = d3 ELSE dist = d4 range = 1 ENDIF ELSEIF (d6 < size) done = TRUE IF (d3 <= d6) dist = d3 ELSE dist = d6 range = 1 ENDIF ELSEIF (rw <= 0.0 && iw >= -r) done = TRUE dist = d3 ENDIF ENDIF ;Check line 4 IF (d4 < size && done == FALSE) range = 1 IF (d5 < size) done = TRUE IF (d4 <= d5) dist = d4 IF (rw >= halfside) dist = d5 ENDIF ELSE dist = d5 IF (iw >= r) dist = d4 ENDIF ENDIF ELSEIF (d6 < size) done = TRUE IF (d4 <= d6) dist = d4 IF (rw <= -halfside) dist = d6 ENDIF ELSE dist = d6 IF (iw >= r) dist = d4 ENDIF ENDIF ELSEIF (abs(rw) <= halfside) done = TRUE dist = d4 ENDIF ENDIF ;Check line 5 IF (d5 < size && done == FALSE) range = 1 IF (d6 < size) done = TRUE IF (d5 <= d6) dist = d5 IF (rw <= 0.0) dist = d6 ENDIF ELSE dist = d6 IF (rw > 0.0) dist = d5 ENDIF ENDIF ELSEIF (rw >= 0.0 && iw <= r) done = TRUE dist = d5 ENDIF ENDIF ;Check line 6 IF (d6 < size && done == FALSE) range = 1 IF (rw <= 0.0 && iw <= r) done = TRUE dist = d6 ENDIF ENDIF IF (done == TRUE) z = 124.0 * dist / size + range * 125.0 ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "Star Of David Mandel" maxiter = 2000 param Radius caption = "Radius of inscribed circle" default = 0.1 hint = "Controls size of star." endparam param Width caption = "Element width" default = 0.02 hint = "Controls element width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam } StarOfDavidMyEqn { ; Paul Carlson init: bool done = FALSE complex w = #pixel complex c = @JuliaCoords float range = 0 float size = @Width float r = @Radius float halfside = 1.73205080756888 * r int skip_iters = @skip int iter = 0 #z = 252 loop: complex w2 = w * w complex w = c * (1 - w2) / (1 + w2) IF (iter >= skip_iters) ;Compute all the distances float rw = real(w) float iw = imag(w) float d2 = abs(iw + r) float d4 = abs(iw - r) float d1 = abs( 0.866025403784439 * rw + 0.5 * iw - r) float d3 = abs(-0.866025403784439 * rw + 0.5 * iw - r) float d5 = abs( 0.866025403784439 * rw - 0.5 * iw - r) float d6 = abs(-0.866025403784439 * rw - 0.5 * iw - r) ;Check line 1 IF (d1 < size) range = 0 IF (d2 < size) done = TRUE IF (d1 <= d2) float dist = d1 IF (iw <= -r) dist = d2 ENDIF ELSE dist = d2 IF (rw >= halfside) dist = d1 ENDIF ENDIF ELSEIF (d3 < size) done = TRUE IF (d1 <= d3) dist = d1 IF (rw <= 0.0) dist = d3 ENDIF ELSE dist = d3 IF (rw > 0.0) dist = d1 ENDIF ENDIF ELSEIF (d4 < size) done = TRUE IF (d1 <= d4) dist = d1 ELSE dist = d4 range = 1 ENDIF ELSEIF (d5 < size) done = TRUE IF (d1 <= d5) dist = d1 ELSE dist = d5 range = 1 ENDIF ELSEIF (rw >= 0.0 && iw >= -r) done = TRUE dist = d1 ENDIF ENDIF ;Check line 2 IF (d2 < size && done == FALSE) range = 0 IF (d3 < size) done = TRUE IF (d2 <= d3) dist = d2 IF (rw <= -halfside) dist = d3 ENDIF ELSE dist = d3 IF (iw <= -r) dist = d2 ENDIF ENDIF ELSEIF (d5 < size) done = TRUE IF (d2 <= d5) dist = d2 ELSE dist = d5 range = 1 ENDIF ELSEIF (d6 < size) done = TRUE IF (d2 <= d6) dist = d2 ELSE dist = d6 range = 1 ENDIF ELSEIF (abs(rw) <= halfside) done = TRUE dist = d2 ENDIF ENDIF ;Check line 3 IF (d3 < size && done == FALSE) range = 0 IF (d4 < size) done = TRUE IF (d3 <= d4) dist = d3 ELSE dist = d4 range = 1 ENDIF ELSEIF (d6 < size) done = TRUE IF (d3 <= d6) dist = d3 ELSE dist = d6 range = 1 ENDIF ELSEIF (rw <= 0.0 && iw >= -r) done = TRUE dist = d3 ENDIF ENDIF ;Check line 4 IF (d4 < size && done == FALSE) range = 1 IF (d5 < size) done = TRUE IF (d4 <= d5) dist = d4 IF (rw >= halfside) dist = d5 ENDIF ELSE dist = d5 IF (iw >= r) dist = d4 ENDIF ENDIF ELSEIF (d6 < size) done = TRUE IF (d4 <= d6) dist = d4 IF (rw <= -halfside) dist = d6 ENDIF ELSE dist = d6 IF (iw >= r) dist = d4 ENDIF ENDIF ELSEIF (abs(rw) <= halfside) done = TRUE dist = d4 ENDIF ENDIF ;Check line 5 IF (d5 < size && done == FALSE) range = 1 IF (d6 < size) done = TRUE IF (d5 <= d6) dist = d5 IF (rw <= 0.0) dist = d6 ENDIF ELSE dist = d6 IF (rw > 0.0) dist = d5 ENDIF ENDIF ELSEIF (rw >= 0.0 && iw <= r) done = TRUE dist = d5 ENDIF ENDIF ;Check line 6 IF (d6 < size && done == FALSE) range = 1 IF (rw <= 0.0 && iw <= r) done = TRUE dist = d6 ENDIF ENDIF IF (done == TRUE) z = 124.0 * dist / size + range * 125.0 ELSEIF (iter == #maxiter - 2) ;Force color for maximum iterations done = TRUE #z = 251 ENDIF ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "Star Of David MyEqn" maxiter = 2000 param JuliaCoords caption = "Julia Coordinates" default = (0.15,1.26875) hint = "The Julia set coordinates." endparam param Radius caption = "Radius of inscribed circle" default = 0.1 hint = "Controls size of star." endparam param Width caption = "Element width" default = 0.02 hint = "Controls element width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam } StarOfDavidNewt1 { ; Paul Carlson init: bool done = FALSE complex c = #pixel complex w = sqrt((1 - C)/6) float size = @Width float r = @Radius float halfside = 1.73205080756888 * r int skip_iters = @skip int iter = 0 #z = 252 loop: complex w2 = w * w complex w3 = w * w2 complex w4 = w * w3 complex Err = (w4 + (C-1)*w2 - C)/(4*w3 + 2*(C-1)*w) w = w - Err IF (iter >= skip_iters) ;Compute all the distances float rw = real(w) float iw = imag(w) float d2 = abs(iw + r) float d4 = abs(iw - r) float d1 = abs( 0.866025403784439 * rw + 0.5 * iw - r) float d3 = abs(-0.866025403784439 * rw + 0.5 * iw - r) float d5 = abs( 0.866025403784439 * rw - 0.5 * iw - r) float d6 = abs(-0.866025403784439 * rw - 0.5 * iw - r) ;Check line 1 IF (d1 < size) range = 0 IF (d2 < size) done = TRUE IF (d1 <= d2) float dist = d1 IF (iw <= -r) dist = d2 ENDIF ELSE dist = d2 IF (rw >= halfside) dist = d1 ENDIF ENDIF ELSEIF (d3 < size) done = TRUE IF (d1 <= d3) dist = d1 IF (rw <= 0.0) dist = d3 ENDIF ELSE dist = d3 IF (rw > 0.0) dist = d1 ENDIF ENDIF ELSEIF (d4 < size) done = TRUE IF (d1 <= d4) dist = d1 ELSE dist = d4 range = 1 ENDIF ELSEIF (d5 < size) done = TRUE IF (d1 <= d5) dist = d1 ELSE dist = d5 range = 1 ENDIF ELSEIF (rw >= 0.0 && iw >= -r) done = TRUE dist = d1 ENDIF ENDIF ;Check line 2 IF (d2 < size && done == FALSE) range = 0 IF (d3 < size) done = TRUE IF (d2 <= d3) dist = d2 IF (rw <= -halfside) dist = d3 ENDIF ELSE dist = d3 IF (iw <= -r) dist = d2 ENDIF ENDIF ELSEIF (d5 < size) done = TRUE IF (d2 <= d5) dist = d2 ELSE dist = d5 range = 1 ENDIF ELSEIF (d6 < size) done = TRUE IF (d2 <= d6) dist = d2 ELSE dist = d6 range = 1 ENDIF ELSEIF (abs(rw) <= halfside) done = TRUE dist = d2 ENDIF ENDIF ;Check line 3 IF (d3 < size && done == FALSE) range = 0 IF (d4 < size) done = TRUE IF (d3 <= d4) dist = d3 ELSE dist = d4 range = 1 ENDIF ELSEIF (d6 < size) done = TRUE IF (d3 <= d6) dist = d3 ELSE dist = d6 range = 1 ENDIF ELSEIF (rw <= 0.0 && iw >= -r) done = TRUE dist = d3 ENDIF ENDIF ;Check line 4 IF (d4 < size && done == FALSE) range = 1 IF (d5 < size) done = TRUE IF (d4 <= d5) dist = d4 IF (rw >= halfside) dist = d5 ENDIF ELSE dist = d5 IF (iw >= r) dist = d4 ENDIF ENDIF ELSEIF (d6 < size) done = TRUE IF (d4 <= d6) dist = d4 IF (rw <= -halfside) dist = d6 ENDIF ELSE dist = d6 IF (iw >= r) dist = d4 ENDIF ENDIF ELSEIF (abs(rw) <= halfside) done = TRUE dist = d4 ENDIF ENDIF ;Check line 5 IF (d5 < size && done == FALSE) range = 1 IF (d6 < size) done = TRUE IF (d5 <= d6) dist = d5 IF (rw <= 0.0) dist = d6 ENDIF ELSE dist = d6 IF (rw > 0.0) dist = d5 ENDIF ENDIF ELSEIF (rw >= 0.0 && iw <= r) done = TRUE dist = d5 ENDIF ENDIF ;Check line 6 IF (d6 < size && done == FALSE) range = 1 IF (rw <= 0.0 && iw <= r) done = TRUE dist = d6 ENDIF ENDIF IF (done == TRUE) z = 124.0 * dist / size + range * 125.0 ELSEIF (|Err| < 0.000001) done = TRUE #z = 251 ENDIF ENDIF iter = iter + 1 bailout: done == FALSE && |w| < 1.0e10 default: title = "Star Of David Newton 1" maxiter = 2000 param Radius caption = "Radius of inscribed circle" default = 0.1 hint = "Controls size of star." endparam param Width caption = "Element width" default = 0.02 hint = "Controls element width." endparam param skip caption = "Iterations to skip" default = 0 hint = "Iterations to skip" endparam }