Welcome to Fractal Forums

First of all, I'm so embarrased because I messed up things in a incredible way in my last post.
A mistake in my formula file for UF5 made a graph that wasn't what I wanted, and also I posted a formula that didn't work as I presented it.

So I deleted the previous topic and now I start again...

I was wondering about combining two 1D Mandelbrot sets (the formula applied only to real numbers), in order to obtain a 2D map of values, without using complex numbers at all.

This is the formula I made:

f1=f1^2+x
f2=f2^2+y

Z=abs(f1-f2)

bailout value for Z: 4

So if the difference between the result of the two functions i'm iterating at the same time, becomes larger than 4, the point it's outside the set, and leads to a value for painting the pixel just like the standard mandelbrot.

I use abs function, and not the modulus to obtain the distance of the two points, because I'm measuring the linear distance in the same 1D real line.
Off course the result is a 2D mapping of the values, but the formula itself works in 1D.

Here's the result:


The whole set

(http://img814.imageshack.us/img814/5594/fractalr1.jpg)


The interesting area

(http://img191.imageshack.us/img191/7870/fractalr2.jpg)


Deeper zooms

(http://img714.imageshack.us/img714/5982/fractalr3.jpg)

(http://img209.imageshack.us/img209/89/fractalr4.jpg)

(http://img26.imageshack.us/img26/4283/fractalr5.jpg)

(http://img708.imageshack.us/img708/1378/fractalr6.jpg)

(http://img707.imageshack.us/img707/8128/fractalr7.jpg)

Did you see that there are 'minisquaredbrots'? :)

The first thing I tried was adding f1+f2 instead of obtaining it's difference and it works, but I like more the patterns obtained with this method.



Well, I'm not a mathematician, just a very curious guy... but I think there's something here that can tell us more about the m-set.

I really don't know much about mathematical theory of the m-brot, only the basic stuff, so perhaps any of you can tell me more about it.

I'll be waiting for your comments...

P.S.: sorry about my mistake in the other post.

I tested the Julia version and it works great!

initializing values:
f1=x
f2=y
c=(real constant)

and then iterating:
f1=f1^2+c
f2=f2^2+c
z=abs(f1-f2)

The constant c defines the pattern, and the bailout value the density of it.

This is the result for values c=-1.7134806 and bailout=6.5  (I used orbit traps for coloring it)

(http://img694.imageshack.us/img694/298/1djulia.jpg)

Ok, I thought it was kind of interesting... perhaps not.

Here it's another pic anyway, with another method.

(http://img51.imageshack.us/img51/7820/burbujitas.jpg)

It looks like you might be onto something.  I wonder if anybody else has come across this before. 

Did the previous image use the simple escape time algorithm for coloring?  I think it's cool that it has a 3d look to it.

Kali, I'm very interested in what you've done. I'm shocked that such a simple method can produce chaotic images. I haven't been able to reproduce your results, but with some experimenting I can make pictures with a fractal appearance.

(http://i1122.photobucket.com/albums/l540/Fractal_Ken/KaliMethod1.png)

I intend to examine your excellent idea some more as I have time.

Kali, I'm getting close to reproducing your first image. I'm using a bailout threshold of 2, rather than 4, on Z = abs(f1 - f2). I'm pretty sure of why I misunderstood: This new criterion is the same as bailing out when Z squared is greater than 4.

The 3d variant is also interesting

A zoom into the last one

Kali,

 By chance, yesterday, I noticed a new formula in Chaospro 4.0 called "Mandelbrotnew" which apparently is the normal Mandelbrot but where one gets to define i^2 as something besides -1. If I set i^2 = 0.5, I get an object very similar to yours except rotated by 45 degrees. So perhaps your formula can be cast as redefined complex multiplication? Very nice.

-mike

Hi sonofthort, I used basic coloring method in UF5 with setting on "Real part", instead of "Iteration"... However don't know really how it works :)

Ken, my mistake (again). I use to evaluate Z in UF5, the syntax |Z|, because if not, the program gives an annoying warning message that "the imaginary part is being ignored". So, as the imaginary part for this formula is always 0, I leave as it is, but I thought that |Z| means the modulus (the modulus should be =Z if the imaginary part is 0), but no, |Z| means "modulus squared", just like you said. Sorry for the inconvenience and thanks for your interest!
I'm not really very experienced in all of this, but since I know about the Mandelbrot set and how's generated, I'm kinda obsessed with learning, researching, and perhaps discovering something new about how it works and the implications of it...

@trafassel, thanks for the 3D images... I was thinking of asking Jesse to make a formula for Mandelbulb 3D to see how it looks...
I'd like to know how you implemented the 3D version of it

@msltoe, interesting... it looks similar to what I get if I evaluate the bailout with the sum of the two functions (I used this method in the last image I posted). Don't know about the implications of this yet... let me do some math about what you are telling.

Regards,

Please note that I answered to all in three different posts
I say this because perhaps you go to the last post I wrote and didn't notice the previous... (I know, I must answer to all in one post)

Now I want to show you something:

I managed to implement in UF5 what Mike said about changing the result of i². First I just made a standard Mandelbrot using real variables, and not the built-in complex variables that UF5 has. Then, in the part where the square of the imaginary part is calculated, I changed the - sign with + (this implies that i²=+1).
I got this:

(http://img413.imageshack.us/img413/8010/diamondyb.jpg)

Nothing but a boring black diamond shape

But with a bailout of 1.5, I got a small area of patterns:

(http://img132.imageshack.us/img132/3595/smallpatternarea.jpg)

I decided, intuitively, to change the way of evaluating the formula. I put a small bailout value of .1, and evaluated if the modulus were smaller than this.

And then...

(http://img689.imageshack.us/img689/4503/rombo1.jpg)

A closer look:

(http://img191.imageshack.us/img191/6617/nocomplex.jpg)

The same patterns again. Or at least very similar...

 I will try to make some study of this patterns when I have some more time.

Meanwhile I'd love to hear any idea or conclusion.

I'm going to take a shot at expanding on Mike's suggestion: presenting general formulas which encompass both the Mandelbrot set and Kali's ideas.

     Iterate (x, y) = (f(x, y), g(x, y)) + c
     Stop if h(x, y) > b

x and y are real variables [(x, y) is complex; typical notation would be z = (x, y)]
f, g, and h are real-valued functions
c is a complex constant [pixel dependent in the Mandelbrot case; pixel independent for Julia's]
b is a real constant [the bailout threshold]

For Kalibrots :): f(x, y) = x², g(x, y) = y², and h(x, y) = |x - y|.

For the Mandelbrot set: f(x, y) = x² - y², g(x, y) = 2xy, and h(x, y) = sqrt(x² + y²) [the modulus].
Note: You get f and g by using the definition of complex multiplication to compute z², where z = (x, y).

Please excuse my mistakes and imprecisions; I'm a rusty mathematician trying to balance simplicity against generality.

Ken

trafassel: the 3-d julia versions might look more ordered than the m-set. Also, the inverse set (like you did with the mandelbox) might show a lattice of blobs.

kali & fractalken: thanks for looking into my suggestion. Whoever invented "Mandelbrotnew" in ChaosPro must've seen this first ;) When people were looking for the 3-D mandelbrot, they explored various definitions of quaternion multiplication, but I don't remember seeing the 2-D version.

-mike

I like the notion, but tweaked it a bit, using two different 1D Julia sets (using the same set on each axis was just too symmetric for me).  Here are a couple of examples using my Rose Range Lite coloring in Ultra Fractal.

(Sorry if this shows up twice--my images were too large so I had to try again.)

Sorry, the last 3d pictures uses |x|+|y|+|z| instead of |x|+|y|-|z| for the bailout value.

Here is the correct 3d fractal.

Another start value

Nice pics, @lkmitch, I have also tried the Julia version with differents values for each function, it works nice.

---

Good work, @traffassel, The first looks like some kind of 3d cantor sets, and the second is a nice architectural piece :)
Did you try using abs function, like abs(x-y-z) or abs(x+y+z)?
And perhaps inverting the bailout setting for values that tend to zero? (I mean setting a small bailout value and exiting the iteration loop if the values get smaller than this)

P.S.: What do you use to render? I'd love to have a 3D renderer that let's me edit the formula and the drawing method as I want... I'm planning to code one myself.

---

@Ken, any new results?

---

As for me, I just discovered this:

Using the formula/method I first described, but evaluating abs(f1+f2) and setting the bailout to values getting close to 0, I got this kind of bifurcation map (I had to fine-tune the bailout and max iteration values to get a nice view)

(http://img406.imageshack.us/img406/1200/bifurcation.jpg)

And this is evaluating abs(f1-f2)

(http://img209.imageshack.us/img209/8553/bifurcation2.jpg)

I used just plain inside painting (paint only the points inside the set, the same color)


Then, after trying several things, I got this strange drawing:

(http://img140.imageshack.us/img140/7649/sound1m.jpg)

I looked closer and it's a waveform!

(http://img163.imageshack.us/img163/3568/sound2.jpg)

I got this by evaluating f1*f1-f2*f2, with a bailout value of .0000000001 (remember that I look for values that get smaller than this) and max iterations above 1000

(http://img163.imageshack.us/img163/3585/sound3.jpg)

It definitely looks like a plot of a sound wave to me, don't you think? it has different frequencies and amplitudes, I wonder how it sounds.
I'll try to get this waveform somehow by programming a VB.NET code and perhaps I can make it sound!

I don't have any conclusion as for now, I leave it for you.
( Can´t think too much as I' having a bad headache :( )

Fantastic pictures Kali, the results of your experiences are so beautiful, and the first two pictures above are very impressive! I wonder what your fractal is trying to tell us with its strange waveform. That's pure fractal sound. Anyone to translate it to .wav?

You wrote:
>Did you try using abs function, like abs(x-y-z) or abs(x+y+z)?
> And perhaps inverting the bailout setting for values that tend to
> zero? (I mean setting a small bailout value and exiting the iteration loop
> if the values get smaller than this)

No, I use abs(x)-abs(y)+abs(z)   

I used Gestaltlupe (http://www.boitels.de/Gestaltlupe/) for 3d drawing of arbitrary formulas.

Isn't this related to the Lyapunov function?

Cool picture and a great idea! This could be a really neat approach to making fractal music.


Here's an image which uses Kali's initial method, but with bailout based on sqrt(x² + y²) instead of |x - y|.

(http://i1122.photobucket.com/albums/l540/Fractal_Ken/KaliMethod2.png)

I see what look like barcodes within the picture.

Thanks @bib for your words (I love your artwork) and @trafassel for the info, I just downloaded the program, I'm about to try it. I realy like the images you posted.

@matsoljare, don't know about Lyapunov function, but I think it's related somehow to the logistic map, if you see the bifurcations graph I posted (I already know standard Mandelbrot is also related).

What I see, in all diferent variants, it's that the are distortions in the shapes (stretchings) that are always present within the patterns. I'm pretty sure  it's related to the waveform I found. Maybe the distortions obbey or encodes somehow the waveform frequency/amplitude.

I'm still looking for a way to reproduce the waveform, but also we must find how to decode the barcode Ken mentioned :)

Here's a variant based on the formula (x, y) = (x³/y, y²) + c.

(http://nocache-nocookies.digitalgott.com/gallery/5/3752_25_01_11_6_29_49.jpeg)

I think it's a surreal teapot.

I will look into it Kali and get back to you, but for now i think that the fundamental basis of all these patterns is ratios of equivalence. We live in a marvellous age, where we can now visualise our relational patterns.

I think rusty ken! has nailed it for you in terms of generalising your algorithm to the (x,y) plane, but it may be to symbolic for you, so i will look for some natural process for you to think on.

Finally, i would be interested if you could explore outputs for prime number coefficients or constraints as far as possible.

Wow, this is so interesting Kali, even for a novice, cant give you any real input, like the others here, just had to tell you this.
Your images looks very interesting, so does Trafassels 3D versions.... and...
I WANT TO HEAR THAT SOUND!!!! :)

(http://img163.imageshack.us/img163/3585/sound3.jpg)

Regards
Johan

PSSSSCCCCHHHHHHHHHHHHHHH

:D

Me too!

So I did something about it   O0

http://www.youtube.com/watch?v=vaFtbOicjSY

And - OF COURSE my desktop wallpaper is Lissa!!  I just couldn't bring myself to crop Her out   :devil:

That's part one of a couple stages.  I'll post more over the next day or 2.

I began by using a jpg to wav program that makes music out of pictures (found here: http://rekkerd.org/virtual-ans-image-to-sound-converter/ )

Next I'll show how to convert the wav to midi voices and compile them into something a bit more Musical  :music:

Sockratease, the conversion you did is super cool!

Kali, don't quit your day job to compose music quite yet.  ;D

@Sockratease: Nice try, and the program is cool but it doesn't convert the waveform to audio, it just uses any JPG to produce sound out of it.
I tried to get a proper soundwave image, but it allways looks like a compact waveform just like any audio editing software shows when it maps a wave file to show it entirely on screen, but if I zoom or stretch the fractal to get better resolution, it just doesn't look like waves at all.

Anyway, here's a better resolution image: (it's bigger than the size the forum shows)

(http://img210.imageshack.us/img210/6076/fractalsound.jpg)

It's still kind of fun to make sounds with that program, thanks for let me know of it  :)

@Ken I'm also a little bit musician but I think that even the fractal do better than me  :)

Thanks, Ken & Kali.  Glad you found it amusing   O0

I tried to make clear that the software just uses jpg data and not the waveform's image.  I doubt any procedure exists to get "true" sound from just an image of a waveform.  Still, it's based on the waveform!

I'll turn it into something more musical tonight and post the results later.

Meanwhile...

I found this as a "suggested" video on youtube on the same page my video was on:

http://www.youtube.com/watch?v=3Br57CsDAFw

It's the Mandelbrot Set converted to sound using a much better system.

From the author:

I think this subject bears further investigation...

Here the remaining pictures of the original formula in this thread (Bailout: abs(x-y+z)  ).

Same scene in small and high iteration.

...

We've got something really new here, and super funky colors  O0
Bravo Herr Doktor Trafassel!

Very beatiful and interesting pictures, trafassel!


Today I tried to understand the "bifurcation maps" I posted, and I tried this with just one 1D formula;
Here's the plot of the values after each iteration placed on the Y-axis, for each real value on the X-axis.

(http://img94.imageshack.us/img94/3521/bifurcationmap.jpg)

So this is where the bifurcation maps I got come from.

But it seems like it's something already known, as I was reading in some old forum's posts.

Now I will look for the "soundwave" again, if I have some time. I think it's still a wave but made of strange polygons, that stretches very fast in the X axis. I have to deal with bailout and iteration values, and the formula itself to make a decent waveform image, an then I know how to get the values for making it sound!

Wish me luck...

 ;D Here is a new picture to feast your eyes on. There is a parameter file to generate it at a higher resolution if you have Ultra Fractal. Sorry it is not in colour and it is not my formula.

I wrote a program in VB.NET and I made a video that speaks for itself   :)

(click on full screen to watch it properly)
http://vimeo.com/19199378 (http://vimeo.com/19199378)

Tomorrow I'll try to get a .wav file

Great job, Kali! I like the iteration-by-iteration view. The video in your post is kind of small, but it looks real good on Vimeo.

Thanks Ken! I made this to show how the first images of the wave were generated (by accident). I had to think a lot to figure out this, because the first images where generated in ultra fractal and what happened is that the way I evaluated the bailout condition made a image similar to what you get if you plot the iteration values placed on the Y-axis (the 2D bifurcation maps), but I didn't understand at first why the waveform patterns emerged.

I'm looking for a way to generate a sound file with the values, I'll read some documentation on generating .WAV files and try it later.
Don't know if it will work, I must see how to take the values because they aren't just like a standard waveform when you zoom in, but I think I'll figure out a way to reproduce some sound out of it.

Anyway, I'm interested on working on the real waves that forms the bifurcation pattern (you can see them in the video as the iteration count ascend), there must be a proper way of combining them to make something more close to a "fractal waveform".

I'll work on this if I have some time today and maybe I'll open another topic for posting the results.

Bye!

Ok, last post about the waveform inside this topic... I'll start a new topic as soon as I get the sounds.

But here's the processed data to make a proper soundwave

First I detected all the wave "depressions" (don't know if I should call them that way, but seeing the image you get the point)

(http://img88.imageshack.us/img88/909/waveprocessed.jpg)

Then I copy each segment of the wave, and added a copy after that segment but with inverted values.

(http://img412.imageshack.us/img412/5343/waveprocessed2.jpg)

So I have sampled the wave, now I have to make it sound... I'm looking for a .wav library for vb.net to make it easy, otherwise I have to learn the structure of a .wav file to generate it with my own code.

Meanwhile, if you want a text file with some raw data, just ask me.

This is so crazy Kali.
I love it!  O0


:D Probably, but what if... ;)

Yeah, I know it's pretty crazy  :embarrass:

I don't really take this too seriously and I neither have too much expectations as for the results but at least it's a fun way to practice VB.NET programming (I'm an old school VB6 programmer and I'm just learning .NET).

And it's out of curiosity too...

But... as you said: what if?...  O0

For those who are interested, I finally get the sound files of the waveform.

Further posts for this research will continue here:

http://www.fractalforums.com/new-theories-and-research/sound-wave-generation-from-1d-mandelbrot-formula/

Thank you all for showing your interest

Bye!

Just to say Ken has it on the money. Deeper(unecessary) explanation and ( suggestive) exploration start here (http://docs.google.com/viewer?a=v&q=cache:1CGgGUSBBVMJ:myweb.polyu.edu.hk/~mawkmak/personal_web/AMA203/Complex_Numbers.pdf+complex+factors+of+unity+De+Moivre&hl=en&pid=bl&srcid=ADGEEShv8YwsBJhQVdLLp3Ffvr33JPlCgdKv4vfNRcddkpq_jlWJIx-bNwzSR8fNiBDfoN3XZdX7zZTf2wCf4QrTupHLWb7uf8vxhzKYQDu7gQ28OQ6L2cZkHoddyHNOOMA6dFllXkqU&sig=AHIEtbQCaWcW9t58C42VsTtUhGk25BKUFg)

That is really interesting. I am teaching a course on fractals and chaos and will turn my students loose on this one.

Hiya guys and gals! :D

I wonder if any body could render this for me:

c= -π*e^-3, or anu other constant you want to play round with.

I placed it here because of the similarity to Kali's original concept.

I am curious to see what results, aren't you?

I do not know the right commands in your programming language or your fractal generator, but i hope you will ask for clarification if you need it. :-*

Hi jehovajah! (Yes, I'm back (http://www.fractalforums.com/meet-and-greet/el-que-se-va-sin-que-lo-echen/)!)

I want to do what you ask, but I don't know if I'm getting it well:

ø is angle and r is radius? the radius then is equal to the angle? why I should use two variables then, if they have the same value?

Or I should do one iteration loop for a set of values of r from 0 to 2?

Hiya Pablo!

Firstly peace on your household, mi amigo!

Secondly the set of instructions is an outline guideline, as i had no way of giving a general description concisely at the time.

You had started this thread looking at the "mandelbrot" in one dimension, namely the x axis using x = x^2+c? Or some similar notion. These are all cartesian formulations using the x part of the x,y plane. Even rcos ø,rsinø is cartesian.

I want to explore a purely polar form that is r,ø.

Whether one uses phi or theta is irrelevant.

Polar coordinate systems are available in all graphing systems, but i do not know if a fractal generator based on them exists, or whether existing fractal generators can produce polar coordinate outputs with a little modification:
hence my outline is written in a semi script form.

What i have learned so far is that polar coordinate systems in the plane generally do not allow r to become negative, so the only form to allow this to happen is the parametric polar coordinate form.

The second thing i have found out is that exponentiation of positive values is well catered for so that one can write for example a rule y=2^x and plot it but one cannot get a plot for y=(-2)^x unless x is an integer, in which case you can write y=(-2)^round(x) or some other integer giving function.

So briefly, this would be a beginning of the exploration leading to a purely polar mandelbrot i would hope, and there are many things to define and find out along the way.

I tried a function format in one graphing calculator namely

polymand(ø)
r=0
while(r<2)
ø=ø^2-some constant
r=ø
polarplot(ø)
end
r

r at the end is the return for the function, and the plot function for this calculator was able to pass x or ø to the function polymand.

A spiral plot resulted.

It is only after really puzzling that i realised that the expected convolutions were in fact not allowed by this plotting function and that i needed a parametric plotter (http://www.flashandmath.com/mathlets/calc/param2d/param_advanced.html)!
Try this one out to see what i am on about! ::)
This is as far as i have got to date, but i am on holiday!

To do a polar plot in the plane you gnerally specify r for each ø. In the parametric form you specify both r and ø.

My initial interest is to see what spiral forms relate to the mandelbrot.

However in line with your formulation you should try

f(ø)=f(ø)^2+ø

f(r)=f(r)^2+r

for -6.3<r<6.3 and -2π<ø<2π.

You can narrow the range down by trial and error because you will get "overlapping".
The graph need to be a polar plot parametric or otherwise.

Thanks in advance! and please play around with it. :dink:

As a spicer

tap
r(t)=cos((t))^2
theta(t)=sin(t^2) + min(t,sin(t))
        or=sin(t^2) + (-1)^round(t)

into here  (http://www.flashandmath.com/mathlets/calc/param2d/param_advanced.html) with the polar setting to see the kind of possibilities i am expecting in draught form.

r(t)=min(1,abs(4*cos((t))))
theta(t)=(((((((((0^2+t)^2+t)^2+t)^2+t)^2+t)^2+t)^2+t)^2+t)^2+t)

This represents 9 iterations, placed in here (http://www.flashandmath.com/mathlets/calc/param2d/param_advanced.html)

The min bracket and the cos() bracket are attempts to set constraints on the output equivalent to |z|<=1.

Without the abs the negative values of r are evident, but the core remains the same.

This kind of restraint of course leads to a disc shape overall, but i have no way of colouring those polar coordinates that do not escape to infinity.

You also have to be aware that the drawing programme includes lines which trace the course of the pen tip rather than points in the polar mandy.

Probably more useful to use tan(), so i changed it accordingly above.

So i do not mind in the least admitting when i do not understand something, and i do not understand the julia and mandelbrot "processes".

Now this was due to confusion, that is: in my head; and possibly in others(let's look at the pretty pictures to check if it is right or not, cos we do not appreciate it any other way :embarrass:), and this arises from my "preferred learning style".

Apparently these are all the rage amongst the more enlightened educators. Well i must admit: Thank 'h¶h for enlightened educators!! :dink:

Maths would appear to be highly visual, with its notation, diagrams symbol etc, and this can be very off-putting for us highly kinaesthetic  learners! We prefer to get our hands on what we are considering, to immerse ourselves proprioceptively and physically and pragmatically into the subject. We want to walk around the edge of a rhombus or scale the heights of seahorse valley, not just look at it.

So following this lead i constructed the "julia process" for f(x)=f(x)^2+c a recursive definition of f(x),

Now for me f(x) means a recipe  with the main ingredient being x (eggs? :evil1:)

So i am going to start with 0 eggs and turn the mixer and then add 1 egg.
Thats it.

Because it is recursive that means run through it again, but this time start with what you got in front of you.

Woa!  :suspious: why? (wouldn't you just like to do that sometimes with your teachers? :laugh:)
Erm? i really don't know why! Hey why don't we explore alternatives? :agree:

When you do that you soon find out that reverting back to the original starting point is repetetve and gets you to the same finishing point. Boring after a while :nastyteeth:, but still fundamentally useful.
So let's define recursive in such away that we can distinguish this case from any other case :surrender:

Pay attention at the back of the class! :fiery:(like being in school isn't it? :w00t:"

Any way to cut a long explanation short and to avoid the laborious introduction of notation etc we usually ignore the "trivial" but nevertheless important recursion where we start over, and go on to the feedback case .

This is how i get
0^2+1
(0^2+1)^2+1
((0^2+1)^2+1)^2+1
(((0^2+1)^2+1)^2+1)^2+1
......

So i can write
f(0)=f(0)^2+1 to describe the above.

In the recipe the ingredients are 0 and 1, the method of combining the ingredients is recursive: f(0)=f(0)^2+1; and this is the method written in shorthand. I need one more instruction in the method: how many imes do i do it? i will call that the mixing instruction(iteration control).

That is all very good but what do i do with the mixture?

Well ususally i  separate it into pans and put it in the oven and cook until ready.

Mmmm!  :happy: Lovely Julia cake!

I now have unprecedented control over the Julia: i can vary how i start so x can run from -∞ to +∞ and i still only add one egg at each iteration! I can let x run along some limited range while only adding 1 egg. I can allow x to be periodic, hyperbolic, complex , whatever and run through a range in these fields rings or groups and still only add one egg!

The point is these variations i think would still be classed as a Julia whatever the cake baked!

However the second i start to vary the number of eggs i add each iteration thats when it becoms unclear as currently described. to see why i will need to construct the Mandelbrot process.



 
  :wtf: where did this come from? :hmh:
Random key pressing i guess! Those damn monkeys! :rotfl:
 
 Step one you say we need to talk
 
 He walks you say sit down it's just a talk
 
 He smiles politely back at you
 
 You stare politely right on through
 
 Some sort of window to your right
 
 As he goes left and you stay right
 
 Between the lines of fear and blame
 
 And you begin to wonder why you came
 
 
 
 Where did I go wrong, I lost a friend
 
 Somewhere along in the bitterness
 
 And I would have stayed up with you all night
 
 Had I known how to save a life
 
 
 
 Let him know that you know best
 
 Cause after all you do know best
 
 Try to slip past his defense
 
 Without granting innocence
 
 Lay down a list of what is wrong
 
 The things you've told him all along
 
 And pray to God he hears you
 
 And pray to God he hears you
 
 
 
 Where did I go wrong, I lost a friend
 
 Somewhere along in the bitterness
 
 And I would have stayed up with you all night
 
 Had I known how to save a life
 
 
 
 As he begins to raise his voice
 
 You lower yours and grant him one last choice
 
 Drive until you lose the road
 
 Or break with the ones you've followed
 
 He will do one of two things
 
 He will admit to everything
 
 Or he'll say he's just not the same
 
 And you'll begin to wonder why you came
 
 
 
 Where did I go wrong, I lost a friend
 
 Somewhere along in the bitterness
 
 And I would have stayed up with you all night
 
 Had I known how to save a life
 
 

The Mandelbrot process

f(c)=f(c)^2+x

I think right thar is the source of 1 level of confusion ! :elvis: That change right thar! Uh huh huh! :siren: :elvis:

Call the po-lice! :police:

So a mandelbrot cake has a different ingredient called c(seed? :evil1:)

So lets start with no seed in the bowl. i mix it then i add any amount of seed i like!
Thats it

So now i do the recursive bit and suddenly the amount of seed i added becomes fixed!

so f(c)=f(c)^2+x =>f(c)=f(a)^2+a where a is the amount i added after the first mix which then becomes  f(c)=f(c)^2+a by the 3rd mix.

So this is how i get

0^2+x
(0^2+x)^2+x
((0^2+x)^2+x)^2+x
(((0^2+x)^2+x)^2+x)^2+x
((((0^2+x)^2+x)^2+x)^2+x)^2+x
...........
f(c)=f(c)^2+x would be the shorthand version ,

This formula therefore obscures a very important procedural step which occurs at the outset within the first 3 iterations.

So to see the difference that the mandelbrot procedure makes we have to get past 2 iterations!

Now the above formula apparrently says that the mandelbrot is a combination of a constant part and a variable part, like the julia but the variable is not squared and a constant added rather the value of the function is kept constant between iterations then squared ans a variable added.

This is much more complex combining than in the julia and equivalent to spooning in ingredients into a cake mixture,stirring until well mixed and then spooning in some more!

Anyone know why bakers do that?

Any way, it should be clear that x can be anything variable, so it could be a function of any sort, a variable on any ring group or field, etc and as lonf as it is combined in this precise and complex way we can call it a mandelbrot cake (EU regulations permitting! ;D)

But again also i now have unprecedented control over the recipe: i can change where i start what i keep constant between iterations etc etc.

I hope this has been as useful to you as to me, revealing the complexity of what we are looking at in these 2 processes, and revealing an infinite landscape of other dynamic processes behind the formulation.

At the end of it all i have to concur: the best way to evaluate a Julia or Mandelbrot  (et al) cake is to eat it ! :toast:

I'll have that big slice of Julia cherry pie, with custard! Yummy :gum:

How does this relate to the polarmandy?

try r(t)=min(2,((((t^2-2.000)^2-2.000)^2-2.000)))
theta(t)=t      here (http://www.flashandmath.com/mathlets/calc/param2d/param_advanced.html)

Hey, I was on a mini-holiday with my familiy to have some rest and almost totally disconnected from the world  :blindfold:

I promise to try your ideas tomorrow

Enjoyed your posts, amigo!

That is good to hear Pablo. Hope you have been refreshed :surf: :jam: :banana: :chilli: :worm: :stickingouttongue: :toast:

Using the mandelbrot process try

r(0)=r(0)^2+t
theta(0)=theta(0)^2+t

Here (http://www.flashandmath.com/mathlets/calc/param2d/param_advanced.html)

Has anyone made any inroads into programming a fractal generator that polar plots?

My fiddling about has helped me to see the possible controls for the polarmandy

r(t)=(((((0)^2-0.9)^2-0.9)^2-0.9)^2-0.9)^2-0.9

Theta(t)=(((((0)^2+t)^2+t)^2+t)^2+t)^2+t

0<t<0.2π

The Mandelbrot process maps (r,theta) onto circles of differing radii. some radii shrink to zero some expand to infinity and some negative radii hang about near the radius 1,

So the set identified under this version would be mainly consistent of negative radii.

The theta variation expands or concentrates on a circle so hopefully does not contribute in this format to the definition of the polar mandy.

However we have options of using trig ratios and other functions so the possibilities are endless.

My experience confirms one other thing:The Mandelbrot set and the deformation of the plane into these fractal regions cannot be drawn, it and they can only be sculpted. As such the 3d mandelbrot- the mandelbulb can only be sculpted from space. Thus we have not seen the real mandelbrot until we have carved it from the plane, and similarly the real 3d mandelbrot has to be carved from space.

That we have conception of it is hope that we will find its real life counterparts in free space.

In the last days I was focusing on fractal art and I totally forgot about the polar mandy you proposed... sorry!

I'm on it now, but I think there's a misconception in your ideas. First of all, the Mandelbrot formula doesn't behave like with complex numbers. The interesting range is (-2,0), where the values converges into waves forming a bifurcation pattern if you plot all the iterations. You should saw this in my posts about Mandelwaves.

Outside the range, the values just tend to infinity in a rather uninteresting exponential way. I've learned that the patterns of the 1D Mandy I "discovered" and showed in this thread, are some kind of "interference pattern" between the waves on x and y axis.

I will look for a polar use of this methods, but unfornately I tried what you proposed and nothing relevant occurred, at least for me.

I think you are wrong here:

Because of the plotting you use, that connects the points with lines, you may think that the radius changes, but I tried it and it just draws a circle of the same radius, in a "accelerated" way, with the points of the perimeter getting more separated... this leads eventually to a great distance between the points within the circle's perimeter, and when the lines connects the sequence of points plotted, they cross the circle's insides forming strange patterns but they are not values within the formula results... I hope you are getting it, because it's difficult for me to explain it in english ( otherwise I should try in spanish :) )

Anyway it's a good idea to look for a polar form of plotting, I will try to do something with it and come back to you...

Hiya Pablo,

Yes , i am wrong somewhere!  ;D

I have tried to track it down and i think it is in understanding how the graphers/generators plot and colour the mandy. I am not very skilled at colouring the mandelbrot set, or playing with the escape conditions.

The range (-2,0) i had not even explored properly until now, pursuing the polar mandy!

The bifurcation graph, map i do not fully grasp yet, but i kind of hoped that the plots i would "happen" upon would be versions of that, and you can see it in the drawings but in a "folded" way. In some of the conditions as you limit r to smaller values you get an equally dense lattice in the circle, like the bottom of the bifurcation maps.

Other things i have looked at are limiting the range of theta etc.

This has increased my understanding, but highlight the problem of not having a polar plotter, and not identifying the polar coordinates of points in the mandelbrot set and colouring accordingly.

`if you can Pablo, i wouid appreciate some help,and i too am busy elsewhere at the moment but i will return to correspond.

Ok, Pablo

I have a little time to gather my polarmandy thinking!

First, Why do the polarmandy?
Because we have not explored the mandelbrot in any other reference frame. Maybe we might find it has a different shape or the same shape.

The behaviour of the parts under the iteration may be more naturally explained or not. The distribution of features etc may reveal more coherent features or not,

`much has been done with variations to the mandelbulb,and maybe the polarmandy can do the same for the mandelbrot? Who knows?

For me it is an exploration worth pursuing, but only if we can take time to smell the roses on the way.

Because of my lack of understanding i wanted to explore by trial and error, from simple cases to more complex. Your 1D approach appealed from that point of view, but i have no real clue as to how to proceed,or even what to expect.

The first things i have done is clarify and examine some assumptions, both in the idea of the mandelbrot process, and the visualisation of the set.

My first assumption was that the set cannot be "drawn" only "carved" or printed, but i wanted to see what happened if i applied the form of the madelbrot equation to a drawing programme. It seemed to draw spirals or circles .

Gradually i realised that parametric graphers were necessary, and the relations between the measures(r,theta) and the parameter could be explored.

This was obscuring the fact that drawing was being pursued not sculpting. So i realised that playing around with the parameter, even setting up an iterative mode was not the same as developing the polarmandy .

Thats where i got to really, but i have doe some exploring i have not posted.

I was tired last night so i stopped.

What i did next was to challenge my assumption that the mandy cannot be drawn. This notion was based on some initial research i did into what the hell the mandelbrot set was. The idea ofg a pre image stuck with me which basically meant that the basis set of the function, that is the ingredients of the recipe contain the form of the mandelbrot set and we are only discovering it by a process of elimination. Hence my sculpting analogy. I was thinking of Michaelangelo at the time!

It seemed easier at the time to go with that idea particularly as colouring schemes depended on it.

However the function map "draws" something, i realised and i questioned why it was not the mandelbrot set. What does the recipe actually produce?

Well it ain't spaghetti bolognese :dink:

The recipe involves endlessly mixing and cooking so it aint bi-scuits(twice cooked) either :crazy:

The function maps a set onto itself, so some element s of the set are going to be "hit" at each iteration. If we colour only those within the |z|<2 boundary that get hit we wiil get a circle, so this is why the pre image defines the set. however if we colour those hit by how many times they get hit i felt that a shape akin to the mandelbrot might begin to emerge as the concentration of hits in that area.

I do not think it will be a clear as the mandelbrot, but it should resemble.

So with that idea in mind i set about exploring how to "draw" a rough outline of the mandelbrot using polar coordinate reference frame.

Found some interesting stuff, took time to look at the flowers produced and just gently meanderd about... it was lovely.


So back to you .

Using you information i proposed the following mandelbrot polar process

r(0) =r(0)^2+(-1+cosø), 0<=ø<=2π, r(0) initially =0.

The controls are The integers and ø and the number of iterations.

Play around with this and get back to me.

This code by mackc (http://www.fractalforums.com/index.php?action=profile;u=1123) may be able to be modified for the purpose of producing a polar mandy?

http://wonderfl.net/c/A4Om/read



package 
{
    import com.bit101.components.HSlider;
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.Sprite;
    import flash.events.MouseEvent;
    import flash.utils.setTimeout;

    /**
     * Calculating fractional mandelbrot using
     * polar vs cartesian form of complex numbers.
     *
     * Click below slider to zoom in.
     *
     * @author makc
     */
    public class Test extends Sprite
    {
        public var bmp:BitmapData;
        public var pow:HSlider;

        public var x0:Number = 0;
        public var y0:Number = 0;
        public var z0:Number = 100;

        public function Test ()
        {
            addChild (new Bitmap (bmp = new BitmapData (465, 464)));

            // quick test of PolarComplex' add()
            var foo:PolarComplex = new PolarComplex; foo.init (1,  2);
            var bar:PolarComplex = new PolarComplex; bar.init (4, -7);
            foo.add (bar); trace (foo.re (), foo.im ()); // 5, -5

            pow = new HSlider (this, 10, 10, change);
            pow.setSliderParams (2, 3, 2);
            pow.width = 445;
            pow.tick = 0.01;

            render ();

            stage.addEventListener (MouseEvent.CLICK, zoom);
        }

        public function change (whatever:* = null):void {
            setTimeout (render, 100);
            pow.enabled = false;
        }

        public function render ():void {
            doMandelbrot (x0, y0, z0, pow.value, new CartesianComplex, new CartesianComplex);
            doMandelbrot (x0, y0, z0, pow.value, new PolarComplex, new PolarComplex, 232);
            pow.enabled = true;
        }

        public function zoom (whatever:*):void {
            if (mouseY > pow.x + pow.height) {
                var i:int = mouseX;
                var j:int = mouseY % 232;
                var cx:Number = x0 + (i - 232.5) / z0;
                var cy:Number = y0 + (j - 116.0) / z0;
                z0 *= 2;
                x0 = cx;
                y0 = cy;
                change ();
            }
        }

        public function doMandelbrot (centerX:Number, centerY: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++) {
                var cx:Number = centerX + (i - 232.5) / zoom;
                var cy:Number = centerY + (j - 116.0) / zoom;
                C.init (cx, cy);
                Z.init (cx, cy);
                var m:int = 0, n:int = 20;
                while (m < n) {
                    // Z = Z^P + C
                    Z.pow (power); Z.add (C);
                    // bail out?
                    cx = Z.re ();
                    cy = Z.im ();
                    if (cx * cx + cy * cy > 4) break;
                    m++;
                }
                bmp.setPixel (i, j + startY, 0x10101 * int (255 * m / n));
            }
            bmp.unlock ();
        }
    }
}

interface IComplex {
    function init (x:Number, y:Number):void;
    function add (c:IComplex):void;
    function pow (p:Number):void;
    function re ():Number;
    function im ():Number;
}

class CartesianComplex implements IComplex {
    private var x:Number = 0;
    private var y:Number = 0;

    public function init (x:Number, y:Number):void {
        this.x = x;
        this.y = y;
    }
    public function add (c:IComplex):void {
        this.x += c.re ();
        this.y += c.im ();
    }
    public function pow (p:Number):void {
        var ap:Number = p * Math.atan2 (y, x);
        var rp:Number = Math.pow (x * x + y * y, p / 2);
        this.x = rp * Math.cos (ap);
        this.y = rp * Math.sin (ap);
    }
    public function re ():Number { return this.x; }
    public function im ():Number { return this.y; }
}

class PolarComplex implements IComplex {
    private var a:Number = 0;
    private var r:Number = 0;
   
    public function init (x:Number, y:Number):void {
        a = Math.atan2 (y, x);
        r = Math.sqrt (x * x + y * y);
    }
    public function add (c:IComplex):void {
        // I have no magic formula
        // so let's do it hard way
        var ax:Number = re ();
        var ay:Number = im ();
        var bx:Number = c.re ();
        var by:Number = c.im ();
        // c = a + b
        var cx:Number = ax + bx;
        var cy:Number = ay + by;
        // r = |c|, but normalize a 1st
        ax /= r;
        ay /= r;
        r = Math.sqrt (cx * cx + cy * cy);
        // rotate a 90° left and store in b
        bx = -ay;
        by = +ax;
        // transform c into basis a, b
        var dx:Number = cx * ax + cy * ay;
        var dy:Number = cx * bx + cy * by;
        // finally, calculate new angle
        a = a + Math.atan2 (dy, dx);
    }
    public function pow (p:Number):void {
        a = a * p;
        r = Math.pow (r, p);
    }
    public function re ():Number { return r * Math.cos (a); }
    public function im ():Number { return r * Math.sin (a); }
}

These were created in grapher on the mac, but the programme is buggy. Curvuspro is available as a free download and easier to interact with.


These polynomial expressions of the mandy iteration for polar coordinates are for research, so change anything to explore what happens.

The bits in green i do not understand yet. The orange bit i do not understand if it is colouring the initial point relative to the iterated point at break, or the iterated point relative to the initial point at break.

In any case Z.pow (power) needs to be looked at in a bit of detail.

interface IComplex {
    function init (x:Number, y:Number):void;
    function add (c:IComplex):void;
    function pow (p:Number):void;
    function re ():Number;
    function im ():Number;
}


This defines IComplex as an interface but i do not understand what that means.
IComplex is then called in a class designation, but also recursively in its definition?
.

Or maybe the interface defines IComplex and the designations are for information to the reader only,or rovide a meta data linking the class and the interface. I don't understand! Is it some kind of container? it seems to allow a variable or a structure or a construct object to take a pointer.


class CartesianComplex implements IComplex {
    private var x:Number = 0;
    private var y:Number = 0;

    public function init (x:Number, y:Number):void {
        this.x = x;
        this.y = y;
    }

Part one of the interface.


   
public function add (c:IComplex):void {
        this.x += c.re ();
        this.y += c.im ();
    }

Part 2 of the interface,


    public function pow (p:Number):void {
        var ap:Number = p * Math.atan2 (y, x);
        var rp:Number = Math.pow (x * x + y * y, p / 2);
        this.x = rp * Math.cos (ap);
        this.y = rp * Math.sin (ap);
    }
    public function re ():Number { return this.x; }
    public function im ():Number { return this.y; }
}

Part 3 of the interface.

class PolarComplex implements IComplex {
    private var a:Number = 0;
    private var r:Number = 0;
   
    public function init (x:Number, y:Number):void {
        a = Math.atan2 (y, x);
        r = Math.sqrt (x * x + y * y);
    }

This is a repeat of part 1 of the interface for polar complex forms.


    public function add (c:IComplex):void {
        // I have no magic formula
        // so let's do it hard way
        var ax:Number = re ();
        var ay:Number = im ();
        var bx:Number = c.re ();
        var by:Number = c.im ();
        // c = a + b
        var cx:Number = ax + bx;
        var cy:Number = ay + by;
        // r = |c|, but normalize a 1st
        ax /= r;
        ay /= r;
        r = Math.sqrt (cx * cx + cy * cy);
        // rotate a 90° left and store in b
        bx = -ay;
        by = +ax;
        // transform c into basis a, b
        var dx:Number = cx * ax + cy * ay;
        var dy:Number = cx * bx + cy * by;
        // finally, calculate new angle
        a = a + Math.atan2 (dy, dx);
    }

This is the repeat of part 2 and the part that relates to possible programming of the polar mandy,


    public function pow (p:Number):void {
        a = a * p;
        r = Math.pow (r, p);
    }

This is a repeat of part 3 of the interface for polar complex.


    public function re ():Number { return r * Math.cos (a); }
    public function im ():Number { return r * Math.sin (a); }


For the polar mandy i think i would need to develop part 2 of the interface by adding a new class in line with Kali's and Ken's definitions of what is going on in the mandelbrot on the reals, but introducing the polar mandy distinctions.

I did a quick search and found this  (http://books.google.com/books?id=As2xeIwS6OgC&pg=PA206&lpg=PA206&dq=polar+mandelbrot&source=bl&ots=lBXb_jDRqD&sig=7tPemNRsxPT2Z2wBIprX9uXyLpM&hl=en&ei=IdaSTYzJGs24hAf6p8mODw&sa=X&oi=book_result&ct=result&resnum=10&ved=0CD4Q6AEwCQ#v=onepage&q=polar%20mandelbrot&f=false)

in which it is revealed that Benoit worked with polar coordinate but he kept theta set at a fixed value and recursively defined r. Thus i have been exploring a more general case than he initially did!

<iframe frameborder="0" scrolling="no" style="border:0px" src="http://books.google.com/books?id=As2xeIwS6OgC&lpg=PA206&ots=lBXb_jDRqD&dq=polar%20mandelbrot&pg=PA10&output=embed" width=500 height=500></iframe>

This is another relation to keep you going  while i think on!
This is only 3 iterations but manages to keep between 1 and -2 on the ±(r,0) radials, while zooming elsewhere.

interface IComplex {
    function init (x:Number, y:Number):void;
    function add (c:IComplex):void;
    function pow (p:Number):void;
    function re ():Number;
    function im ():Number;
}


This defines IComplex as an interface and i think it means that a kind of "structure" of pointers is set up. This structure is a higher level form of struct or union or class. This allows classes to be gathered into a structure and pointers in a recursive call.


IComplex is then used in a class designation. This recursive definition
 is only possible through pointers

The interface defines IComplex and the designations are   linking the classes and the functions to the interface. i am guessing! Is it some kind of container? it seems to allow a variable or a structure or a construct object to take a pointer.

What follows is one implementation for Icomplex
class CartesianComplex implements IComplex {
    private var x:Number = 0;
    private var y:Number = 0;

    public function init (x:Number, y:Number):void {
        this.x = x;
        this.y = y;
    }

Part one of the interface.


   
public function add (c:IComplex):void {
        this.x += c.re ();
        this.y += c.im ();
    }

Part 2 of the interface,


    public function pow (p:Number):void {
        var ap:Number = p * Math.atan2 (y, x);
        var rp:Number = Math.pow (x * x + y * y, p / 2);
        this.x = rp * Math.cos (ap);
        this.y = rp * Math.sin (ap);
    }
    public function re ():Number { return this.x; }
    public function im ():Number { return this.y; }
}
Part 3 of the interface.

This implementation returns x and y to the instance of icomplex. That means that the software arrangement that has been programmed by the author defines an "object" with attributes. When the main function pulls it all together the programmer can choose an example of the "idea"  of the object or "objects" . These objects are like ghosts in the machine and by naming one of them they appear with all the attributes given to them.  This naming is called instancing.

The programmer wanted to be able to use common mathematical "language"  so the instances would look and behave like  mathematical ideas called complex numbers. The class definition or declaration really pulls together all the essentials of a complex number, and shows how convoluted the idea is!

We may tend to claim these ideas are basically simple, but the programming hoops that are involved in the idea show the convoluted complexity.

 What follows is a second implementation of Icomplex

class PolarComplex implements IComplex {
    private var a:Number = 0;
    private var r:Number = 0;
   
    public function init (x:Number, y:Number):void {
        a = Math.atan2 (y, x);
        r = Math.sqrt (x * x + y * y);
    }

This is a repeat of part 1 of the interface for polar complex forms.


    public function add (c:IComplex):void {
        // I have no magic formula
        // so let's do it hard way
        var ax:Number = re ();
        var ay:Number = im ();
        var bx:Number = c.re ();
        var by:Number = c.im ();
        // c = a + b
        var cx:Number = ax + bx;
        var cy:Number = ay + by;
        // r = |c|, but normalize a 1st
        ax /= r;
        ay /= r;
        r = Math.sqrt (cx * cx + cy * cy);
        // rotate a 90° left and store in b
        bx = -ay;
        by = +ax;
        // transform c into basis a, b
        var dx:Number = cx * ax + cy * ay;
        var dy:Number = cx * bx + cy * by;
        // finally, calculate new angle
        a = a + Math.atan2 (dy, dx);
    }

This is the repeat of part 2 and the part that relates to possible programming of the polar mandy,


    public function pow (p:Number):void {
        a = a * p;
        r = Math.pow (r, p);
    }

This is a repeat of part 3 of the interface for polar complex.


    public function re ():Number { return r * Math.cos (a); }
    public function im ():Number { return r * Math.sin (a); }
}

This implementation returns rcosa and rsina.

You can't have an implementation without a configuration of the hardware. And you can't have a configuration without the hardware!  So starting with hardware we surprisingly talk about these physical things in abstract terms! General terms that encompass all possibilities. It is no wonder we get a little stressed with computer programming!

So what is missing is an infrastructure for plotting polar coordinates, an interface for representing polar coordinates, and a class declaration of polar coordinates.

For the Polar mandy exploration i think i would need to develop part 2 of the interface by adding a new class  called Reals in line with Kali's and Ken's definitions of what is going on in the mandelbrot on the reals, and then introduce the polar mandy class.

Seems rather obvious now, but i have to point out that the parameters of the reference frame, despite there relationship, are entirely independent. Thus r does not have to be defined in terms of theta, nor does x have to be defined in terms of y.

To obtain Kali's plots we simply plot the first function against the second, but to do this we could need a common parameter and thus a parametric representation.

Parametric representation means effectively 2 or more reference frames can be combined to form any set of reference frames we can construct.

Commonly we use a single origin to establish a reference frame in a model. However in reality we need to use as many origin centres as necessary to describe the motion in focus. For example a Fibonacci spiral could be described by 2 centres of rotation superimposed: one describes the type of parabolic curve the other describes how that parabolic curve spirals.

However, useful as parametric relations are they do  restrict the independence of the reference frames, as any measure along these frames are not in general linked to each other , but they are linked to the transformations of the reference frames.

These are parametric and can be independently varied. This particular form shows what happens to points on  curve after itereation 4 times. The curve is specified by .

Trig functions are used to keep the initial input values between 1 and -2

The conception is clear to me now. We need only to define a class called the reals. Then using exactly two reals as Kali does we need to plot them not on a pair of orthogonal axes, but on a set of generalised axes such as we call polar coordinates.

Therefore we simply set r= f(x) and = f(y) exactly as Kali prescribes. The polar plot of these functions is what I am after so I just need to alter the plotting call to plot in this way.

It suddenly seems clear to me that to plot (r,) on a pixelated screen i am going to have to use x,y coordinates for screen position! Thus if r_n= r_n-1^2+r₀, and for some suitable ranged function for then

x=r_n*cos
y=r_n*sin

or if f(x), f(y) are Kali's mandelbrot  functions on the reals, form f(r),f(); that is perceive Kali's functions as implicit functions of the radius independent of the implicit function of the angle.

Then
x= f(r)*cos (f()
y= f(r)*sin (f().

Now, if we want to really "mess" about we could use 2 (r,)'s and form r as a parametric equation in t, or functions of phase shifted.

(r₁,)= (sin(t),cos(t))

(r₂,)= (t²+sin(t),cos(t)-1).

These are then iterated and the results plotted (r₁,r₂) for cartesian plot or (r₁*cos(r₂),r₁*sin(r₂)), for a polar plot. We can form many combinations for the plots, to explore what results..

Based around code by makc.


interface Kalireal {
    function init (x:Number, y:Number):void;
    function add (c:Kalireal):void;
    function pow (p:Number):void;
    function re ():Number;
    function re2 ():Number;
}

This hopefully saves rewriting too much code.


class CartesianKalireal implements Kalireal {
    private var x:Number = 0;
    private var y:Number = 0;

    public function init (x:Number, y:Number):void {
        this.x = x;
        this.y = y;
    }
    public function add (c:Kalireal):void {
        this.x += c.re ();// not sure what this means
        this.y += c.re2 ();//
    }
    public function pow (p:Number):void {
/*this function converts to polar so that raising to a power can be performed for a complex number so i need to check it for appropriateness for real exponetiation. it then converts back to be able to print on screen. The polarmandy would just do this second part at this stage.*/
        var ap:Number = p * Math.atan2 (y, x);
        var rp:Number = Math.pow (x * x + y * y, p / 2);
        this.x = rp * Math.cos (ap);
        this.y = rp * Math.sin (ap);
    }
    public function re ():Number { return this.x; }
    public function re2 ():Number { return this.y; }
}


This is a rough conception that will need modifying to work "proper".



class PolarKalireal implements Kalireal {
    private var a:Number = 0;
    private var r:Number = 0;
   
    public function init (x:Number, y:Number):void {
        a = x;
        r = y;
    }
    public function add (c:Kalireal):void {
     this.x += c.re ();// not sure what this means
        this.y += c.re2 ();//   
    }
    public function pow (p:Number):void {
        a =a*p;
        r = Math.pow (r, p);
    }
    public function re ():Number { return r * Math.cos (a); }
    public function re2 ():Number { return r * Math.sin (a); }
}

TBC. further revision required.

 
    public function init (x:Number, y:Number):void {


The iterators or loop  variables represent our ability to move through the plane and to record our position in the plane by cartesian coordinates. In this case they are analogous to screen coordinates and we can translate them to pixel position.
But now we want to translate them to a distance from the origin and an angle from the horizontal, we draw a right angle triangle and derive
a = Math.atan2 (y, x);
        r = Math.sqrt (x * x + y * y);
[Because i am starting with the polar coordinates i can just write
        a = x;
        r = y;]
   
So now every position in the plane can be moved through and recorded by iterators a and r, instead of x and y.

However instead of writing code using the idea ofa and r, we elect to retain x and y and translate., for some ueful reasons i might add.

Now if i were defining addition in couples i would make it straight forward and what we call vecctorlike addition

(a,r) +(a,r)=(2a,2r) etc but we put a constraint on what we do: whichever system we use must produce the same geometry!
Why?

Now to tackle the constraint we have to model addition in cartesian using the coordinates in polar. Clearly we cannot expect the different motion freedoms to exactly the same and so we expect some translation as before. We use the right triangle like a coder and decode between the two systems.
 
    public function add (c:Kalireal):void {
        // I have no magic formula
        // so let's do it hard way
  makc earlier defined a cartesian add which he could actually call here:
        var ax:Number = re ();
        var ay:Number = re2 ();
        var bx:Number = c.re ();
        var by:Number = c.re2 ();
        // c = a + b
        var cx:Number = ax + bx;
        var cy:Number = ay + by;

Makc now proceeds to do the translation to cartesian from polar! But first he has to get the polar conversion code that applies to each position, which is given in cartesian form to start with! :banginghead:

        // r = |c|, but normalize a 1st
He already has r for every position, which he obtains by initialisation, and he has a by the same process.
however he does not have the ratio form of the sine and cosine functions. So he decides to implement the ratio forms for this "complex number" which is calling the add method

        ax /= r;/*do not understand this code*
        ay /= r;/*

But why does he set the r equal to c? or rather how does this code set the radius equal to the radius of c?
 
        r = c;/*to here*/


He needs the radius of the result to translate the polar version back to the cartesian version. But he already has the cartesian version. Could thiss be the necessary update of r?
 
He now sets up a  dot product  multiplication between c and the trig ratios  for this "complex number"  and c and this complex number rotated
       // rotate a 90° left and store in b
        bx = -ay;
        by = +ax;
        // transform c into basis a, b
        var dx:Number = cx * ax + cy * ay;
        var dy:Number = cx * bx + cy * by;
 This he indicates translates c into a vector over the basis of these unit vectors a,b which are orthogonal by design, and out of phase by a rotation  of π/2  .


So by this stage he has updated r and now he can update a   

// finally, calculate new angle

        a = a + Math.atan2 (dy, dx);
    }

This code seems to illustrate the convoluted nature of translating cartesian addition into polar representation. In fact, nowhere is polar addition exhibited. What we see is cartesian addition with the result converted to polar.

I wonder then if it would not be possible to call cartesian add, and then call polar init for the new result?

In any case we have a clear example of how "chaos can arise out of order"!

Because i do not want to model cartesian vector addition, but to look at purely polar interaction i have to define a new polar addition , which is very simple.

I have also looked at the power method, and again this does not require conversion so i have modified it for another purpose, but it is experimental at this stage.

The idea now is to work toward the design constraints Kali sets out.

I have considered this topic further in the light of competing vector algebra ideas and explained it in my blog (http://my.opera.com/jehovajah/blog/2011/11/22/polar)


z(x,y)= (r²-ø²)cos(2rø)+i*(r²-ø²)sin(2rø) + c(x0,y0}= x + iy + c(http://nocache-nocookies.digitalgott.com/gallery/9/410_25_11_11_1_14_08.png)
(http://nocache-nocookies.digitalgott.com/gallery/9/410_24_11_11_8_35_08.png)
The above is the polar mandelbrot which is intrinsic to a spherical system.

I have spent a confusing time learning about relationships in Quasz, and in general.

The bailout conditions are still a wonder to me, as there are several different possibilities, logical comparisons included, and results that show the parser attempting to make sense of any typing errors!. Every time i think i have an inkling i forget something and have to re-look at it. It is a sign of unfamiliarity with relational calculus, intuitive geometrical interpretation and the "damned negative image" of a sculpted form.

Any way it will do me good to seek the essentials of relations, as Hamilton demonstrates their fundamental importance to all vector/tensor algebras, especially in revealing the trigonometric basis of them all.

In the case of Quasz the real and imaginary parts are initiated from a standard "for loop" instruction, but then are variable according to the actions performed on the quaternion they are a part of. If the vectors i,j or k are missed out the resulting image still reflects the attachments of the coefficients( real, imaginary, ...) because the for loop structure preserves this relationship in oder to define a block of quaternions. The vectors only become necessary for the variable case where they serve as identifiers for combination and summation, and the app has functions that do this automatically, with the inbuilt quaternion algebra.

To override the inbuilt assignment the coefficients have to be "multiplied" that is attached to the required vector manually. To visualise what this means graphically is where i struggle, and so i run several experimental versions to get a "feel".

The mandelbrot is a relationship between the real coefficient and the imaginary coefficient, but it turns out, also between the for loop structure. So the for loop structure is a meta pattern that has to be acknowledged to understand how the mandelbrot works. It is no just the formula. It is also the for loop subsection within which the formula is evaluated. That equates to spatial disposition of the interacting factors and is akin to "action at a distance" considerations .

Within Quasz and possibly within space, attributes within the same boundary surface ,ie plane, effect each other differently to attributes in different boundary surfaces interacting, at least in terms of the re-presentation of the data. The re-presentation of the data is according to the tool chosen and thus says more about the tool than my experience in space. Familiarity with the tool in all its applications is therefore necessary to divine the correct "meaning" of any output.

I progress as i hope the picture will show.
(http://nocache-nocookies.digitalgott.com/gallery/9/410_24_11_11_10_50_50.png)
The polar mandelbrot from the rear.
(http://nocache-nocookies.digitalgott.com/gallery/9/410_24_11_11_8_41_40.png)

This experience also serves to illustrate the danger of conceivng  number as an entity as opposed to an adjective to an entity. The entity here is the angle between two vectors in a common plane.