Welcome to Fractal Forums

When i first looked for a 3d generator to match the output that c programmers were rendering in the chase for the holy grail mandelbulb, i had no money and no time to learn how to programme these generators, i just had formulae.

I did not understand quaternions and still do not fully comprehend them, but at least i apprehend their origin , relation to rotating space and their fundamental spherical geometric basis and their role as the first general group algebra, giving sense to Galois theory.

Complex numbers as they are called, but couples as Hamilton called them, were rigorously if not with prolixity, placed on a firm algebraic a theoretical basis by Hamilton. For the first time since Wallis a mathematician took the imaginaries as a doctrine not an oddity.

Therefore the difference between thinking in numbers and thinking in quaternions and couples is the difference between thinking with your eyes closed to thinking with full 3d stereoscopic vision.

The numbers which seem so real drop away to become scalars of real solid surfaces or objects or particulate regions. The operations of aggregation and disaggregation become condensing or evaporating motions and the movement of regions in space are described by Roulettes / Trochoids.

Here is a simple introduction (http://nrich.maths.org/5627) to rotation, similar to Paolo's paper, but less intense.

There are three ways to generate Julia sets using Fractal Zplot:
The manual way involves entering the complex constant values for a known Julia set into the
complex c boxes in the Parameters window.

This seems to indicate that the c boxes are the place to set the fixed values of c when z is changing And the fixed initial value of z when c is changing.

This seems quite subtle or confusing, after all c and z  are variables aren't they? We have to upgrade to the notion of parameter.   These are parameters that measure the same types of thing but clearly different things . Normally parameters reference dimensions so what are the dimensions?

z is any vector in the field and c is a fixed orientation. This structure under the  system produces the julia set.
Now if we allow both z and c to be moving vectors in the field and we evaluate by fixing z and letting c roam we get the mandelbrot set. They should be related and they are, but they show a different relationship and that is an anti symmetric relationship.

If i fix c and let z roam , that is different to fixing z and letting c roam. However if z=c then they should produce the same result. So a julia is the same as a mandelbrot if the initial vector that is fixed is the same?

No because the order is not the only thing that is changed, the sequence of evaluation is also changed . It is a small 3 step change but it makes the total difference.

For any 2 vectors this process links them like a tensor or rather processeS. The spaciometry is the same but the processes are different.
Fix c: pick z: square z and add c get r: square r and add c continue until stop:print r: pick new z: keep c :repeat   :julia
Fix z as zero: pick c: square z and add c get r: square r and add c continue until stop:print r: pick new c: set z to zero :repeat :mandelbrot

We have a graphic example of how crucial sequence is at key or tipping points. We also see that "chaos and randomness etc" are not squeezed out of  a deterministic process , and contrariwise a nondeterministic process does nor preclude an ordered result. Order therefore is not a defining characteristic. Ultimately motion and sequence determine everything.

The marvelous thing about motion is that in the end it explains everything!

So terry can have one vector which he can use in both processes provided that at the turn of the iteration he picks a new z for a julia and a new c for a mandelbrot.

If this is internal what can i change?

http://vimeo.com/16337818

I often meditate on this video by Lazarus Plath.

.

This is some code to help focus on how Quasz works and what you can do. It is not Terry's code but Makc's, which i have altered to use as an explanatory tool


   public function doMandelbrot (centerX:Number, centerY:Number,centerZ:Number, centerH:Number, zoom:Number, power:Number, Z:IComplex, C:IComplex, startY:int = 0):void {
            bmp.lock ();
            for (var i:int = 0; i < 465; i++)
            for (var j:int = 0; j < 232; j++)
            for (var k:int = 0; i < 232; k++)
            for (var w:int = 0; j < 232; w++) {
                var cx:Number = centerX + (i - 232.5) / zoom;
                var cy:Number = centerY + (j - 116.0) / zoom;
                var cz:Number = centerZ + (k - 116.0) / zoom;
                var ch:Number = centerH + (w - 116.0) / zoom;
                C.init (cx,cy,cz,ch);// There is an option to customise this initial scalar set in the parameters section of Quasz//
                Z.init (cx, cy,cz,ch);//  ''  //
                var m:int = 0, n:int = 20;
                while (m < n) {
                    // Z = Z^P + C
                    Z.pow (power); Z.add (C);//this sequence is only applicable to the mandelbrot et al, Quasz provides a function
                                                        //input  facility//
                    // bail out?
                    cx = Z.re ();
                    cy = Z.im ();
                    cz = Z.imj ();
                    ch = Z.imk ();
                    if (cx * cx + cy * cy > 4) break;//although this should be generalised, Terry seems to have left it as it is.
                    m++;
                }
                bmp.setPixel (i, j + startY, 0x10101 * int (255 * m / n));
                bmp.setPixel (k+ startZ, w + startH, 0x10101 * int (255 * m / n));//this would probably involve another layer, or some kind of offset, or even layers.//
            }
            bmp.unlock ();
        }//Based on code by makc

Quaternion Surface Zplot, is a sophisticated application which is based on the extension to the "complex" couples we call the quaternion quads or quats! That unenviable foursome of "real" scalars that Hamilton ordered  :order: into existence after the unruly triples or threesome  :groupbutts: would not behave! Well they do say "three is a crowd!" ;D

Quasz is sophisticated because it has its own parser, limited but nonetheless powerful, and this enables it to parse compile and link user ( thats you and me -hi  :howdy:) generated code and formulas, and then run them. You will notice it doing this when you put your own code in.

However Quasz has its own inbuilt or precompiled library of functions and you often do not need to put your own stuff in. so the first thing you can change is your function.

To do his you go to the edit menu and go to functions and types

After you have chosen what function you want to create or explore press ok and wait.

You do not have to let it complete the plot but you do have to let it compile your choice.

The next choice in the edit menu is parameters

Here you will set up the fixed value for the quaternion tensorvector that will be used later in the mandelbrot process or the julia process or, surprise surprise :surprised:  octonion, or cquat processes. :verysurprised:

The main controls you might alter here are the scalar of iterations or the bailout scalar.

There is a section called "slice" but it would be better called "dimension parameters", or "tape measures".

Simply put we have a tool that cuts space in 3 dimensions. We are going to represent this on a surface which only has 2 dimensions cut out of space, so we are going to go mental! :scared:  :crazy:

We have to "imagine the 3rd dimension as coming out of the screen! imagine that! :laugh:

Hey,it gets worse! :sick: In quads we have four ordered scalars, that is four tape measures, so we can not easily squash  :flowers: this data set into our 2 dimensional screen even if we imagine the 3rd and fourth dimensions as coming out of the screen ! :thumbsup1:

So What we do is just show three and match them up with the 3 dimensions on the screen X to the right and horizontal  :over: Y to the top of the screen and vertical  :banana:, and  Z coming "right atcha" and horizontally near or far from you   :kissmyass:

But then we have rotation! :crazyeyes: :rotating:  :butt: :rotfl:  :music:   :help:

The easiest way to grasp this is with your hands!  Make out like you are going to pick up a tray ! then your left hand has a thumb, for the Y direction an index finger for the Z direction and a second finger for the X direction. your right hand gives you the mirror image and helps with those >π turns!. You still got to imagine z as coming out of the screen. :nastyteeth:

With this in mind the negative scalars represent " :surf: clockwise" rotation! These "digits' are the axes of rotation, and i guess its best to start with a Z axis to rotate around.Good Luck  :stickingouttongue:

When you have chosen press draw or ok and let the app compile your new settings and plot the image.

So now i can think a bit more clearly about this control. The two controls of the many under type are julia and mandelbrot. These are mean to help the beginner get the right control for either of these 2 fractals. However what they actually do is a subtle process which i only got partially right above.
The generator only has one set of control loops, and so if they are used to define a quaternion one really ha only one control over referencing a quaternion space. However i can write a specific quaternion that does not use the control loop variables , and i can mixx up the control loo variables to get quaternions that are referenced differently in the loop progession. I have to sit and figure this out  if i want to avoid simple coupling due to the fact that one control system references the quaternion strructure. What i do is set up independent loop ariables within the main control loops to give me full flexibility in doing this.

However, Quasz has only 2 sets of independent loop variables, because it only uses 2 fundamantal quaternion Z and C. You can ue these to make your own quaternions but they will always be some  variation of Z and C , and you need to figure out how they are related to ensure you have the behaviour you think you have! most of us will just go with the random choice button!

Any way you can make some exotic quaternions by mixing these loop variable up in the quaternion, but you need to keep track of your quaternion definition.

So now how does the type julia work as a process?

As far as i can make out it restricts the C loop variables, by decouping them from the main loop control, but it allows the z loop variable full access to the main loop controls.Thus z can take , as an INITIAL value any quaternion in the quaternion block, while c has a constant fixed quaternion. When the iteration loop is called the z quaternion is handed off to the z loop variables , and the main control loops now wait for a signal to update. This only happens after each iteration loop has done its job however many times it has been set to cycle or interrupt.
So as i said c remains fixed throughout the whole process.

Now the so called mandel brot process is different. C is coupled to the main loop controls z is decoupled. Z is has to be assigned a quaternion. By default its initial value is the zero quaternion, and this is its Initial value at the beginning of any iterationloop because it is not updated by the main loop control. The initia; z quaternion can be set, but that either has to be done using the c loop variables, or independently in the programme outside the iteration loop.
When the iteration loop start the main control loop ands off to the iteration vaiables, which means for the duration of the iteration c is fixed from a main loop setting. z is free to take quaternions determined by he loop procees and the initial z value. Only when the iteration loop completes does the main loop update c and the z quaternion returns to it fixed initial value.

This is the meaning of the mandelbrot type.This means that the last part of the sequence is not keep z but set z to zero  pick new c

The quaternions form a reference frame which are more fundamental than any based on the polar or Cartesian paradigms.  I have just started to explore that frame in Quasz on a theoretical basis as opposed to an intuitive trial and error basis.

I am currently setting up a model of attraction and repulsion in order to unify gravity and electromagnetism. Quasz is particularly apt for this kind of research.
Http://my.opera.com/jehovajah/blog/2012/08/30/attraction-and-repulsion-with-quaternions