Welcome to Fractal Forums

I'd like to share something I discovered a while ago: real 3D newton fractals. I couldn't find existing posts/usage of this method so I'm posting it here.


Background: when I was a child and playing around with fractal algorithms on a PC I of course also wrote newton fractals and tried lots of variants.

A special one I tried was: "What if I replace the function f in x := x-f(x)/f'(x) with its absolute value?" Of course I had to adjust the formula itself, too - f is now rather like a terrain (as it yields a nonnegative real value (height) for every complex input (position on ground plane)). Determining the value and derivative at a given x now gives a tangential plane and I simply pick the intersection with the ground plane that's closest to x. (|f(x)|' being the vector of deriving |f(x)| spatially by each of x's components we get the new formula as: x := x - |f(x)|*|f(x)|'/|f(x)|'²)

Surprisingly the resulting "newton" fractal looked exactly the same as the original complex newton fractal. And I was puzzled as didn't expect that and also couldn't explain that. (Nowadays I know that it's due to f(x) being holomorphic.)


Later I was thinking about the problem of expanding 2D fractals to 3D. As it's well-known there's no natural extension of complex numbers to 3 dimensions. But then I remembered my discovery above as it yields a natural extension at least for this specific kind of newton fractal. By transforming |f(x)| for f(x) = x³-1 I get:

|x³-1| = |(x-1)(x+.5+i*sqrt(3)/2)(x+.5-i*sqrt(3)/2)| = |x-1|*|x+.5+i*sqrt(3)/2|*|x+.5-i*sqrt(3)/2|

The right part has one factor per null of the original polynomial. And it no longer does any fancy stuff with complex numbers, just adding and subtracting, so it works with vectors as well. And extending that to more than 2 dimensions is trivial.

GLSL pixel shaders (running in your browser) for a simple 3D newton fractal of a polynom with one null for each of a tetraedron's 4 vertices:

* cross section: http://glsl.heroku.com/e#1348.2 (http://glsl.heroku.com/e#1348.2)
* flight through fractral rendered as fog: http://glsl.heroku.com/e#1368.0 (http://glsl.heroku.com/e#1368.0)

Sorry... but where is the fractal detail?
By the way welcome!

Yes that's a problem: there's no real 3D fractal detail. 3D structure is mostly elongated and bent 2D structure. Maybe a consequence of having chosen the simplest possible way. Nature is just too lazy to add additional details on its own for further dimensions unless being forced to :D

I've also taken a look at examples where a mandelbrot set occurs within a newton fractal. I've seen 2 examples so far (one is here (http://de.wikipedia.org/w/index.php?title=Datei:Newton-lplane-Mandelbrot-smooth.jpg&filetimestamp=20081017234443)) but none of these has a natural extension to 3D. Both work by introducing a varying "constant" to the newton fractal formula and plotting the behaviour depending on the constant's value. But that's also the problem: this added parameter makes it impossible to convert the formula to vector arithmetics and thus to naturally extend it to 3 dimensions.

hello and welcome to the forums ;)

problem with newton is that its bailout condition is opposite to normal escape time conditions :( the newton bails out when a certain value is undergone, whereas normal mandelbrot bailout is reached when a certain value is over-gone ... nice thoughts anyways, and surely worth to think about how to implement a newton 3d fractal ;)

Well inside DIFS shapes it should not be a problem because you can write the DE in a custom way. The problem would be to make it linear using derivates... :(

Pfft. On the contrary. Nature is too lazy to find really complicated solutions when simple fractals do the job just perfectly fine.

Awesome discovery there, though!

Note though: Newtonian fractals aren't the most amazing when it comes to fractal details.
You can sort of see these patterns in the 3D cloud:
(http://www-user.tu-chemnitz.de/~uro/teaching/SS2012-numerik/ueb06/newton-fractal.png)
Just imagine cutting through one of those sections perpenticularly. You'd most certainly get patterns close to the cross-section shown above.

By the way, could you try the secant method too? It doesn't require a derivative at all and it produces slightly richer fractal patterns, because the fractalness of the patterns here sort of actually is an unwanted effect of a not-so-well-converging series. The secant method converges even slower and brings out the patterns more.
(There was a post on this way back on this forum. I remember somebody trying all kinds of Runge-Kutta methods as variations on the Newton method and then heading back to secant because that was the most interesting one by far)

I just tried the secant method. Looks nice. (http://glsl.heroku.com/e#5963.0 (http://glsl.heroku.com/e#5963.0)).

But I don't think this can be transferred to 3D using my method because that would require converting the 2D variant to operate as well on a C -> R formula (e.g. the terrain analogon). And the secant method doesn't work well on terrains as it won't be able to break out of the straight line defined by the 2 starting points.

Cool. These rings are details;) Throught webGL crashed my windows;) Could this benn made solid with 3 threads.

Hypercomplex (bi-complex) Newton cut to a sphere:

http://www.renderosity.com/mod/gallery/index.php?image_id=1181285&user_id=40328&page=6&member&np (http://www.renderosity.com/mod/gallery/index.php?image_id=1181285&user_id=40328&page=6&member&np)

Look here : http://www.josleys.com/show_gallery.php?galid=338 (http://www.josleys.com/show_gallery.php?galid=338)

That was not what I meant. I was talking about fractals that are defined in 3 dimensions, not 2D fractals rendered as terrains.

But nonetheless, thanks for sharing that. I improved the cross section of my fractal by rendering the part below the cross section plane in 3D: http://glsl.heroku.com/e#6026.0 (http://glsl.heroku.com/e#6026.0)
Furthermore, the same fractal clipped to a sphere: http://glsl.heroku.com/e#6026.2 (http://glsl.heroku.com/e#6026.2).
(Warning: the shaders behind these links are demanding to the GPU / gfx driver and might hang your browser or computer)

really nice :)

Fascinating.

There may be a second way to generalize Newton fractals to more dimensions also. Given

(http://i46.tinypic.com/167plc5.png),

compute

(http://i49.tinypic.com/rqytlg.png)

where the denominator is the gradient at x and the division on the right hand side is done by dividing the scalar F(x) by each coordinate of the gradient vector. Each coordinate is thus subjected separately to vanilla Newton's method, with the partial derivative in that coordinate. In theory this should work for any continuous, differentiable real-valued function of a vector space. And "real" can be upgraded to "complex" throughout.

It might also be possible to extend it to some discrete spaces, using a finite field in place of "real" or "complex". However, derivatives and gradient don't exist there, so it would have to be changed to a difference equation of some sort. A (partial) derivative might have to be replaced by, say, f(x + 1) - f(x), for example.

Quaternionic Newton cut to a sphere and sliced to show the hollows:

https://www.youtube.com/watch?v=dnI6r3xsHPE (https://www.youtube.com/watch?v=dnI6r3xsHPE)

Just tried that, doesn't really work because when F(x) is large but ▼F(x) is close to zero for one coordinate this coordinate will get very large in the result. Example:

F(x) = |x|² -> ▼F(x) = 2x

x0 = (1,0.01) -> x1 = (1,0.01) - 1.0001 / (2*(1, 0.01)) = (0.49995, -49.995)

I've also tried to render that but all I get is some colorful dust but no real structures. The formula seems to be incapable of actually reaching the nulls, unfortunately.

first: [ latext ] can be used in postings

second: never use == on comparing floats or doubles, i think you run into a classical instability problem of floating point representation here ;)

use a small delta bias to check if it is so close to zero as you like ;)

just my five cents!

What about this? Compute the gradient vector g at x, then compute x - gF(x)/|g|². That moves x in the direction opposite g and moves it a distance equal to F(x)/|g|.

In your example, (1,0.01) is now moved by (-1,-0.01) divided by the square root of 1.01, so almost right onto zero.

One problem with using methods that converge faster/better than Newton's is (as already mentioned) that you lose any fractal detail - in fact I think I remember trying one myself (Householder's?) and got 3 perfect triangles with straight edges !!

Maybe the extension to general 2D using Jacobian methods can be extended to 3D ?

Edit: Of course the Jacobian does get a little messy using 3 dimensions instead of 2 ;)

See my "Multivariable Newton" formula in mmf3.ufm for Ultra Fractal which essentially gives the Newton for any system of 2 reals - actually it would of course be easy to convert to any system of 2 complex ;) (Which of course gives us 4 dimensions to play with without too much difficulty)

Example:

That's exactly the method this thread is about :-)

Is it? Then there's a few extra absolute bars in your OP. :)