Lambda set symmetry

[megafiddle]

Greetings. New here.

I have generated the lambda set as described in Mandelbrot's "The Fractal Geometry of Nature".
It's based on the function z = zc(1-z) for an initial value for z of (0.5, 0).

My set is not symmetrical horizontally. It is symmetrical vertically.
The main "mass" of the set is symmetrical. The asymmetry is in the branches that extend out from
the main part, and also in the non-set surrounding regions. These parts become progressively more
and more truncated as you move from the right part of the set (x = positive) to the left (x = negative).

I assume it is supposed to have horizontal symmetry? I can't find much on the set itself, just the lambda
julia sets.

I am getting some interesting images, though. If there is an error in my code, I'm going to have to keep
it as new variation.

Anyway , I just wanted to confirm that the set should be symmetrical horizontally.

Also, can the gallery be used for linking to an image?

[bib]

Hi and welcome to fractalforums!

Looking at the standard formula in Ultrafractal, yes, with (0.5,0) as a starting point, the set should be symmetrical about the y-axis.

Here the UF code :

Code:

LambdaMandelbrot {
;
; Mandelbrot set corresponding to the classical Lambda Julia
; set. Use this fractal in Switch mode to find interesting
; Julia sets.
;
; Written by Damien M. Jones.
;
init:
  z = @start
  
loop:
  z = #pixel*z*(1-z)^(@power-1)
  
bailout:
  |z| < @bailout

default:
  title = "Lambda (Mandelbrot)"
  helpfile = "Uf*.chm"
  helptopic = "Html\formulas\standard\lambda.html"
  center = (1,0)
  magn = 0.5
  
  param start
    caption = "Start Value"
    default = (0.5, 0)
    hint = "The starting value parameter can be used to distort the Mandelbrot \
            set. Use (0.5, 0) for the standard Mandelbrot set."
  endparam
  param power
    caption = "Exponent"
    default = (2, 0)
    hint = "This parameter sets the exponent for the Lambda formula. \
            Increasing the real part to 3, 4, and so on, will add discs to \
            the fractal. Non-integer real values and non-zero imaginary values \
            will create distorted Mandelbrot fractals. Use (2, 0) for the \
            classic Lambda set."
  endparam
  param bailout
    caption = "Bailout"
    default = 1.0e20
$IFDEF VER40
    exponential = true
$ENDIF
    hint = "This parameter defines how soon an orbit bails out while \
            iterating. Larger values give smoother outlines; values around 4 \
            give more interesting shapes around the set. Values less than 4 \
            will distort the fractal."
  endparam

switch:
  type = "LambdaJulia"
  seed = #pixel
  power = @power
  bailout = @bailout
}

You cannot "link" images in the gallery, you can just upload them. You can also directly attach an image in a post by clicking on the Additional Options below the text box.

[megafiddle]

Ok, thanks.

I suspected it should be symmetrical, but it seemed to work too well as it was.
Amazing how well these things survive in spite of errors.

What does this refer to, though?

hint = "This parameter defines how soon an orbit bails out while \
            iterating. Larger values give smoother outlines; values around 4 \
            give more interesting shapes around the set. Values less than 4 \
            will distort the fractal."

Is it used for testing the magnitude of z, to determine set membership?

It doesn't immediately follow a parameter like the other "hints".
And the default for "bailout" is nowheres near 4.

[cKleinhuis]

What does this refer to, though?

hint = "This parameter defines how soon an orbit bails out while \
            iterating. Larger values give smoother outlines; values around 4 \
            give more interesting shapes around the set. Values less than 4 \
            will distort the fractal."

Is it used for testing the magnitude of z, to determine set membership?

It doesn't immediately follow a parameter like the other "hints".
And the default for "bailout" is nowheres near 4.

yes, it is used as "bail-out" test, because it is a quadratic operation (z^2) the value can not get smaller when it is
getting above 1 ... depending on the seed value, squaring of a value greater than 2 ( hence the comparison with 4, z^2=4 if z is 2 , to spare calculation cycles the z distance isnt squarerooted ) will most certainly not come back to values below 2

the distortion is created because lower bail out values can lead to certainly wrong guessings, but it can be compared to the iteration depth... iteration is broke up as soon as some bailout is reached

so, and last paragraph about why to set the bailout value higher than the maximum needed for calculation improvements ... the reason is, the value will grow really fast, and even faster and the "smoothing" or smoothed color methods - those that create gradients and not stripes - work with the nice logarithm property, which works very well with big numbers, and they can then use logarithmic arithmetic ( dunno what i am talkin 'bout ) to create the finer gradients

when using big bailout values, the nice thing is that the values do not grow over floating limitations e.g. the bailout is the maximum value the length of the z value
may have, somehow this is then used to map the result to a real gradient

as far as i know can david m. code this thing in sleep mode, or on a chalk board, and can explain you every step

ah, yes, and: welcome to the forums

[megafiddle]

Thanks.

That's what I am currently doing for the mu (Mandelbrot) set, comparing the square of the magnitude of z to 4.0.

Maybe that's the problem with my lambda set; I am comparing the square of the magnitude of z to 1.0.

Ok, found an older working version of my program and changed the test value to 4.0.
Everything is now symmetrical about both axes.

(My program is undergoing some major changes and nonoperational. Had to find a an older version)

My code for the lambda set goes back to the '80s when all I had available was 640 x 480 VGA. Never noticed
the asymmetry until I dusted it off and tried it on a modern PC. Strange that test values of 1.0 and 4.0 both
produce nearly identical sets.

Thanks again, that fixed it. But I am going to have to add my "error" as an option. It did produce some interesting
images. Sort of looks like frosted glass bubbles:

[Vega]

My variant 

[megafiddle]

Nice image!

I haven't done anything with the interior of the sets, just the surronding aura or corona (as I call it).

My program is limited to coloring based on escape time. All the coloring is done by operating on a
1000 entry color lookup table. That's where all the work is right now, adding editing tools for the
table.

Also I'm not familiar with Ultra Fractal and the other software that's out there. In the UF code above,
the bailoutout parameter is set to 1.0e20. Is that related to a "normalized iteration count" algorithm,
for smooth coloring?