Attempt at Unitary Mandelbrot Set

[kram1032]

Just so you can try different configurations, including things like higher-power mandelbrot sets, various polynomials or Möbius transforms:
Take two unitary numbers (as they now may be called) :
, as well as a real constant parameter defaulting to 0
with and , all those values

further define: and analogously

Then I already defined their addition as either:

or:

OR:

-

for , this last one actually should be the most natural definition, directly analogous to what would actually happen in complex numbers. However, it's still arbitrary in some ways.

This is the only ambiguous definition.
I'd recommend, however, to try out all three and see what results in interesting stuff. Fractals tend to be most interesting where you add in arbitrary definitions that are not quite as nice as "correct" addition.

Furthermore we have:



and lastly:



Very much like what would happen in quaternions.
I'll look into what happens if you do a corresponding exponential function which would give rise to all kinds of other interesting transformations.

[kram1032]

So if there is any "true" way to deal with varying phases during addition, I still don't see it.
However, somewhat analogous to the sign varying MSets that were going on a while ago, where the iteration is altered by randomly flipping the imaginary part of z, e.g. randomly taking or as variable to be iterated, I have yet another idea:

Instead of sticking to any fixed rule of what the phase would be after addition, you could just make it be random.
In that variation, you wouldn't even have to keep track of the phase, since after each addition, it would be independendly random again anyway.
In that case, you have a standard quaternion M-set, but with the slight change, that the current product of two numbers (or the current square of a number) depends on a random phase.
This would give rise to irregularities that might break down the boring, circular form of typical quaternion m-sets.

To do this, just do:

are typical quaternions. Additionaly, you introduce a random variable that changes each iteration.
slightly changes how you'd usually square in a way, similar to the rules given in the previous post.

That way you have for each iteration:


This should be really easy to implement.

[Alef]

Waiting for pictures.
It have 4 parts when it's 3D, so as I understand, 4th allaway are 0

[kram1032]

Well, you know how quaternion mandelbrot sets work. This is almost the same.

Or alternatively, you know the cut-planes through Mbulb, Mbox, etc. - You could do a cut-space instead or also try cut-planes.

[Alef]

Will try it. with random numbers seems to be the most easy one, cos I'm not shure about numerical value of p and probably could make lots of mistakes. Is p just a complex angle? Or somehow a value of a quadrant , (1, i) or (-1, i)

[kram1032]

p is any real. It's an angular value, so it's sufficient to constraint it to but if it's not constraned by that, it works just fine as well, since the function wraps around anyway.

As said, in those and above, all interior values are reals.


That being said, is of course any value on the complex unit circle. It's equal to where and are also reals, but the combination, of course is, a complex number. - one that satisfies .

[Alef]

Tried random thing. Different random seeds generate different shapes but result allways is very quaternion like aka revolution surface. Julias are a bitt more interesting throught.
Didn't tried non random, I not quite understand how then does p is calculated and alsou I want to spend time more on finetuning contest images.

Code were like this. Alsou tried with fi = temp:

Code:

temp= seed= random(seed);
fi=( (12*pi*temp) /(randomrange));


 Cx=real(C); Cy=imag(C); Cz=part_j(C); Cw=wplane;//part_k(C);
 zx=real(z); zy=imag(z); zz=part_j(z); zw=part_k(z);
 
 zzx = 2*zw*zx -(zy*zy+ zz*zz)*cos(fi)  +Cx;
 zzy = zw*zy -zx*zz  + (zw*zy +zx*zz)*cos(fi)+ (zx*zy-zw*zz)*sin(fi)	+Cy;
 zzz = zx*zy +zw*zz +(zw*zz-zx*zy)* cos(fi)+ (zw*zy + zx*zz)*sin(fi)	+Cz;
 zzw = zw*zw-zx*zx -	(zy*zy+zz*zz)*cos(fi)	+Cw;
 z= quaternion(zzx, zzy, zzz, zzw);
	zx=zzx;
	zy=zzy;
	zz=zzz;
	zw=zzw; 

[kram1032]

Ok, for the three different kinds of addition I thought of:

The first one with p=q essentially is what you're doing right now already, except
Instead of randomly assigning a new p in each iteration, you randomly assign one at the first iteration and then double it each iteration. - since the phase of C always is set to the phase of Z, you don't actually need to keep track of an individual phase for C.


The second one, you assign a random phase to Z and a random phase to C at the first iteration, and also decide on a third phase factor that is fixed. - if you just put that third phase to 0, the term becomes 1.

Then you take your three phases and plug them into the formula , to obtain your new p. Since in a typical M-Set, C is constant, so would be . Similarly, is constant. Only p changes.

For the last form, you weight the phases with the respective radii of the numbers. E.g. you have:


- where again, and are constants, and you might want to set to 0.

It's simply another variable to keep track of, and you plug it in the same formula over and over again, just like you'd do for the other forumlae.

Maybe also try other cut-spaces to see what other structures lie in this. - although I kinda expected this after finally figuring out how the multiplication and stuff worked out, especially for this random version.

There is a certain ridge in it that I'd not expect on a quaternion M-set. You can see where it opens up. That's unusual for an integer power M-set. Typically, this would only occur on non-integer powers...
That suggests, that the shape isn't perfectly symmetric and if you cut through it, you'll find slighthly distorted M-sets on any but the "main" plane which should still be a perfectly undistorted M-set.

That ridge might also be a result of sampling over the entire space randomly, rather than constraining it to any "proper" rule. - It shows the entire capabilities of this added phase. As said, it should add a reflection to the mix, that originally only was rotation.  If you reduce the sampling space, you should end up with a bit more defined structures. Depending on the phase you choose, you'll end up with something that's pretty much exactly like the "normal" rotation M-set (namely for exactly ) or with a set that's based entirely on reflection (if I'm not mistaken, it should be at ) or, for all the other values, anything in between.

[Alef]

Rendered the same random version formula with cutout. Not as expected;) Interesting enought the same fractal without any cutout looks like some bell like revolution surface, and with a cutout it's something other. I used following code for a cutout, so resulting random sequence is different as if region is cuted it automaticaly bails out on the first iteration.

Code:

//initialisation
autobailout=0;
if (coordZ!=0 && part_j(pixel) < coordZ )	
{
autobailout= bailout +1;
}
//loop
//formula code are here

//bailout
return( |z|+ autobailout < bailout);

Random seed is 1, 40 iterations, colouring by orbits on 2 iteration, same wievport. If I remember my cutout code correctly:

- Cuted of region z<0 (smooth surface, sand colouring).
- Cuted of region z>0, x>0 (fuzzy surface).
- Cuted of region z<0 and x<0 ( quarter, smooth surface).
- No cutouts.

[kram1032]

It looks severely undersampled but these are sort of expected for a purely random case.
Did you already try to, rather than randomly switching the phase each iteration, doubling it? - That would be the first kind of addition I proposed and it should be almost the same as what you have now. Except that you only need to randomly generate a number once and then double it, rather than once per iteration.

What exactly is the difference between the first "whole" set and the second one, the unitary bell?
Did you look at a different set of axes?

[Alef]

Changed random formula so that each point during iterations would go throught the same trajectory of random numbers. So  now it's smooth.

Initialisation:
doonce=0;

Iteration loop:

if (doonce==0)   
{
temp= seed2= random(seed);
doonce=1;
}
else
{
temp= seed2= random(seed2);
}
fi=temp;

///previous formula code

It looks like there are 2 different versions:
- fi trajectory for every point is different. Result looks fuzzy. Start iteration of point with random fi, then during iterations pick random fi or (if I 'm correct) when multiplying fi by 2.

- fi trajectory is identical for all points. Result looks smooth.
Say, fi value during iterations is random but iteration of every point starts with the same random seed, so that trajectory of fi values is the same. Like in this example. Or just chose some starting value of fi and do with it wathever you like.

 Images with starting seed =1.

[kram1032]

those already look a lot better. The cross-section is interesting.
So the images you showed are for a constant per point, that doesn't change at all?

The "correct" version would be a per point that would double each iteration, so . Is that already causing fuzziness?

[Alef]

Random numbers are generated by arithmetical methods, so they aren't undetermined random. If each point is started with same random seed, then for each point next generated random numbers are the same. So neigbouring points are simmilar and result is smooth.

If starting seed for each point is different, then it's proper randomness, but then random number generates totally different sequences, each point is different and result is fuzzy.

First seed = starting seed.
seed (of iteration n+1)= random number = random(seed(of iteration n)  ) 

But with Ф (n+1) = Ф (n) x 2 in 3D it will be a smooth rotation surface like of example above.

[kram1032]

Ok, that sounds more like what I actually expected.
Nothing of this really is a surprise. Let's see now, what other types of addition give. Can you tell me precisely with what you need help to implement them?

If those don't give anything interesting either, all that's left to do is wild experimentation until something interesting pops up. As usual.

Oh, and Julia-sets will be interesting to look at too.

[Alef]

Some easy formula;)
In the shape:

iteration (n)
x= ... +C
y=.... +C
z=...  +C

Ф =some sort of(Ф)

But I think, everything correct quaternion like would result in revolution surface what is kind of boring.