News: Visit the official fractalforums.com Youtube Channel

## The All New FractalForums is now in Public Beta Testing! Visit FractalForums.org and check it out!

 Pages: [1] 2 3 ... 5   Go Down
 Author Topic: Glynn Julia set  (Read 33804 times) Description: 0 Members and 1 Guest are viewing this topic.
gamma
Safarist

Posts: 81

 « on: September 09, 2009, 06:00:31 PM »

Hello everybody.
I found a small, tiny piece of information that Glynn set
is a Julia set of (z = z^1.5 + c).

Try this one:
z = z^1.5 + 0.2

Now it looks like it is made of several fractal trees.
I wonder, are they really trees, beyond our first impression?
For example, Julia sets are quasi-self-similar and IFS fractals are exactly self-similar.
Is this tree similar to an IFS set?

http://www.efg2.com/Lab/FractalsAndChaos/GlynnFunction.htm
 Logged
gamma
Safarist

Posts: 81

 « Reply #1 on: September 09, 2009, 06:07:55 PM »

Here's the parameter file so you be the judge...
bib
Global Moderator
Fractal Senior

Posts: 2070

At the borders...

 « Reply #2 on: September 09, 2009, 09:16:08 PM »

Hello
I can't answer your question. Nevertheless I found this formula graphically interesting and I did this animation some months ago to test motion blur.

 Logged

Between order and disorder reigns a delicious moment. (Paul Valéry)
gamma
Safarist

Posts: 81

 « Reply #3 on: September 11, 2009, 08:58:02 PM »

Great demo

I have 3 interesting leads between the world of IFS fractals and Julia sets:

1. Barnsley tree (Cantor dust, um, no tree)
2. Glynn set (tree)
3. Sierpinski-curve-Julia sets in form of z^p + c/z^q (fat, curvy Sierpinski triangle)

...and lets not forget that for Newton sets we can design the fractal by positioning roots somewhere.
 « Last Edit: September 11, 2009, 09:01:43 PM by gamma » Logged
xenodreambuie
Conqueror

Posts: 124

 « Reply #4 on: September 13, 2009, 12:39:49 AM »

I tried doing this formula with inverse iteration IFS, but I can't find the correct root handling to reproduce the set that forward iteration gives.
Since z = (z-c)2/3 has a rational exponent, the obvious solution has three roots, but it doesn't work. The closest I got was taking the first root and its conjugate, which isn't right either. Does anyone know what it should be?
 Logged

Regards, Garth
http://xenodream.com
gamma
Safarist

Posts: 81

 « Reply #5 on: September 13, 2009, 11:50:14 PM »

Good question, it seems someone successfully used the inverse iteration IFS method for Glynn and many other types!
http://www.brainjam.ca/fractals.html
He claims that we can draw anything into using the inverse iteration method. I am a little bit suspicious of that statement.
"the pictures are rendered using inverse iteration as opposed to escape time algorithms. As a result, only the limit sets themselves are shown, without the razzle dazzle of a surrounding color field"
In my experience, I saw articles where people had trouble with this belief. For example, random chaos game method never or rarely visits some areas of a fractal set. Then they have to tweak the algorithm to help it out by using set-specific mathematics.
 Logged
xenodreambuie
Conqueror

Posts: 124

 « Reply #6 on: September 15, 2009, 12:02:53 PM »

Gamma, that's a good collection of inverse iteration method (IIM) renders. He doesn't actually say you can draw anything with it, just that it's versatile.

The limit set is in principle an invariant that is the same rendered forward or inverse, since either direction always maps any point in the set to another point in the set. But inverse methods only work for functions that have inverses, which is not the general case. (Or for chaotic systems that are defined in the direction of the attractor to begin with.) There are variations on the IIM. I think the standard IIM is a deterministic tree of permutations of the roots to a sufficient depth to plot enough points. The modified IIM (MIIM) varies the depth, pruning branches to get a better coverage. It needs a hit count per pixel. I'm guessing this is what was used at brainjam.ca. Another option would be tuning the choices with Metropolis Hastings; Lycium's the expert on that.

The standard IIM and the standard chaos game both have the problem of not covering Julia sets well, except near c=0. As you mention, it can be tweaked with less random choices, and they do depend on the set and the quadrant of c. I've had some success with this from my own experiments, and found a few improvements this week. Do you have any links to articles about this? I'm probably reinventing the wheel, but if not then I can post what I've found.

Conceptually, a Julia set is just a nonlinear IFS with a transform for each root. If you consider an IFS as a linear part and an optional nonlinear part, then you have a kind of continuous parameter space (apart from changing formulas or other noncontinuous options.)

I think I've figured out the problem with the inverse Glynn set for c=-0.2. In the forward direction (escape time methods), the whole set is repulsive except for the three curls on the left, which form a feedback loop that creates the pattern, roughly between 2pi/3 and -2pi/3. For inverse methods, once a point leaves that region it is attracted to the point near 1.31 on the real line, with no way back. That's no problem for deterministic tree methods, but the chaos methods won't work without a modification to reseed from a repeller point on the left.
 Logged

Regards, Garth
http://xenodream.com
gamma
Safarist

Posts: 81

 « Reply #7 on: September 15, 2009, 10:05:53 PM »

If I can't answer your question, I can offer some muscle. I will see that brainjam guy and he will confess the algorithm or we will buy him out.
Quote
The standard IIM and the standard chaos game both have the problem of not covering Julia sets well, except near c=0. As you mention, it can be tweaked with less random choices, and they do depend on the set and the quadrant of c. I've had some success with this from my own experiments, and found a few improvements this week. Do you have any links to articles about this? I'm probably reinventing the wheel, but if not then I can post what I've found.

I did not read any GENERAL articles, but I saw specific problems solved by setting uneven probability to visit one of the equations calculated in each loop of an IFS algorithm.

Quote
I think I've figured out the problem with the inverse Glynn set for c=-0.2. In the forward direction (escape time methods), the whole set is repulsive except for the three curls on the left, which form a feedback loop that creates the pattern, roughly between 2pi/3 and -2pi/3. For inverse methods, once a point leaves that region it is attracted to the point near 1.31 on the real line, with no way back. That's no problem for deterministic tree methods, but the chaos methods won't work without a modification to reseed from a repeller point on the left.

How did you see that? By hand or in some program? I have Fractint in a sad state, in virtual machine to see the orbits, and David Makin wrote some orbit viewer for Ultrafractal (http://www.fractalforums.com/ultrafractal/how-to-use-ultrafractal-for-science/msg6589/#msg6589). Also I use Matlab, apparently in good faith of learning something.

Regardless of the approach, the fractal must be the same set as a static image. I haven't been working with inverse IFS much.

But, I noticed that Julia sets made with escape time algorithm possess some degree of self-similarity ranging from very complicated quasi-self similarity to more almost-exact self similarity. Some random formula could serve as an example for ugly quasi-similar Julia set, and simple Newton fractal tends to appear minimalistic and very straightforward repetitive.

The other topic of using IIM looks like a real play for analysis of properties of set.
 « Last Edit: September 15, 2009, 10:09:44 PM by gamma » Logged
xenodreambuie
Conqueror

Posts: 124

 « Reply #8 on: September 16, 2009, 10:21:01 AM »

Quote
How did you see that? By hand or in some program?

For this case I just thought about it, as it's easy to estimate where each point will iterate if you draw a unit circle over
the picture to help with the contraction/expansion factor.

For following orbits in z=z^2+c with various c, I used XenoDream with the coloring changed to show the root choice. Then I add a small sphere and move it around, and adjust its iteration limit to see the sequence. Or just set the limit to 2 or 3 and drag the sphere around for an interactive map.

For real(c)>0, the most important orbit is choosing the same root, especially the negative one.
For real(c)<0, the most important orbits have alternating roots. But what I recently discovered is that either trajectory stops if it crosses a quadrant boundary, and some improvement can be made by tracking quadrants to decide whether to alternate or choose randomly.
 Logged

Regards, Garth
http://xenodream.com
David Makin
Global Moderator
Fractal Senior

Posts: 2286

 « Reply #9 on: September 16, 2009, 11:00:29 AM »

Hi, I contacted Peter Liepa about his method for inverse rendering of Glynn Sets etc. - he said it was OK to post his reply here:

Code:
Ok, here's a first cut.  tabs=4.  Even though there may be some
rudimentary C++, this is mainly C.  This code is cobbled together from
various files.  Originally compiled for Win16, never ported to Win32.

I had a custom program that would send 'messages' to methods like this.
FN_RUN is the one you're interested in.  To make inverse iteration work,
and to avoid most of the ISS-like set being sparse, you have to prune
iterations with a cumulative derivative that is too small.  That's what the

I'm not sure whether anything of this is useful.  Your best bet would be to
Julia, and then work from there.  A Glynn set is just a Julia set for an
exponent other than 2.  Usually the exponent is fractional and between 1 and 2.

parmA,B,C,.. correspond to the numbers the pictures.

Good luck,

Peter

#define GLOBAL extern

GLOBAL HWND hWndDynamics ;
GLOBAL HWND hWndParticles ;
GLOBAL HWND hWndMain ; //cheat

GLOBAL double parmA ;
GLOBAL double parmB ;
GLOBAL double parmC ;
GLOBAL double parmD ;
GLOBAL double parmE ;
GLOBAL double parmF ;
GLOBAL double parmG ;
GLOBAL double parmH ;
GLOBAL double temperature ;
GLOBAL DWORD joltPeriod ;
//GLOBAL double frequency ;
GLOBAL double x ;
GLOBAL double y ;
GLOBAL BOOL bGo ;
GLOBAL BOOL bBounded ;
const int MAX_DEPTH=1000 ;

class CTree {
public:
double x[MAX_DEPTH] ;
double y[MAX_DEPTH] ;
double dp[MAX_DEPTH] ;
int choice[MAX_DEPTH] ;
int index ;
private:
} ;

void glynn (int mode)
{
switch (mode){
case FN_RUN:
{
if (parmC==0.0) return ;
int branches = (int)ceil(fabs(parmC)) ;
// if cumulative derivative is larger than threshold, backtrack
if (jtree.dp[jtree.index] > cutoff || jtree.index > MAX_DEPTH-2){
for ( ; ; ){
jtree.choice[jtree.index] = 0 ;
jtree.index-- ;
if (jtree.index==0){
jtree.choice[0] = (jtree.choice[0]+1)%branches ;
break ;
}
if (jtree.choice[jtree.index] < branches-1){
jtree.choice[jtree.index]++ ;
break ;
}
}
}
double xt = jtree.x[jtree.index] - parmA ;
double yt = jtree.y[jtree.index] - parmB ;
double r = pow (::sqrt (xt*xt+yt*yt), 1.0/parmC) ;
double theta  = atan2 (yt,xt) ;
BOOL bNoRoot = FALSE ;
int branch = jtree.choice[jtree.index] ;
double limit = fabs(parmC)*PI ;
theta = theta + TWOPI*(branch - floor((theta+limit)/TWOPI)) ;
if (theta > -limit && theta < limit){
theta = theta/parmC ;
} else {
bNoRoot = TRUE ;
}

if (bNoRoot){
// don't need to assign x, y - just use existing values
jtree.index++ ;
assert(jtree.index<MAX_DEPTH) ;
jtree.dp[jtree.index] = 2.0*cutoff ;
} else {
x = r*cos(theta) ;
y = r*sin(theta) ;
jtree.index++ ;
assert(jtree.index<MAX_DEPTH) ;
jtree.x[jtree.index] = x ;
jtree.y[jtree.index] = y ;
jtree.dp[jtree.index] =
fabs(parmC)*pow(::sqrt(x*x+y*y),parmC-1.0)*jtree.dp[jtree.index-1];
}
}
break ;
case FN_RESET:
{
//jtree.x[0] = -1 ; jtree.y[0] = y ; jtree.index = 0 ; jtree.dp[0]=1.0;
jtree.x[0] = -1 ; jtree.y[0] = 0 ; jtree.index = 0 ; jtree.dp[0]=1.0;
for (int i = 0; i<MAX_DEPTH; i++){jtree.choice[i]=0 ; }
}
break ;
case FN_UPDATEPARM:
cutoff = pow (10.0, max(parmD, 0.0)) ;
dynamics (FN_RESET) ;
break ;
case FN_INIT:
joltPeriod = lifetime = 100 ; temperature = .0 ;
parmA = -0.74543 ; parmB = 0.11301 ; parmC = 2.0 ; parmD=10.0 ;
dynamics (FN_UPDATEPARM) ;
x = y = 0.0 ;
break ;
}
}

----------------------
The sentence

"To make inverse iteration work, and to avoid most of the ISS-like set being sparse, you have to prune iterations with a cumulative derivative that is too small."

was carelessly written.  Better would be:

"To make inverse iteration work, and to avoid most of the IFS-like set being sparse, you have to prune branches of the tree where the cumulative derivative gets below a small threshold - i.e. where the map is highly contractive.  This is just the MIIM method talked about in 'The Science of Fractal Images'"
----------------------
 « Last Edit: December 30, 2009, 08:31:10 PM by Nahee_Enterprises » Logged

The meaning and purpose of life is to give life purpose and meaning.

http://www.fractalgallery.co.uk/
"Makin' Magic Music" on Jango
xenodreambuie
Conqueror

Posts: 124

 « Reply #10 on: September 18, 2009, 02:10:44 PM »

Excellent, Dave! Thanks for that info. With the correct formula for testing root validity, the standard chaos method works, but I was right about it needing reseeding. It also has very poor coverage by default. I was able to get fair results by boosting the runs of same and alternating choices, but less satisfactory than for the quadratic Julia.

Peter's version of MIIM using contractivity is more practical than what I read about using pixel hit counts.
 Logged

Regards, Garth
http://xenodream.com
David Makin
Global Moderator
Fractal Senior

Posts: 2286

 « Reply #11 on: September 19, 2009, 12:44:26 AM »

I never really investigated rendering outlines of Julias using this method but the idea of simply pruning a deterministic IFS tree based on #hits sounded interesting (and easy), so I had a go:

http://www.fractalforums.com/gallery/?sa=view;id=920
 Logged

The meaning and purpose of life is to give life purpose and meaning.

http://www.fractalgallery.co.uk/
"Makin' Magic Music" on Jango
bugman
Conqueror

Posts: 122

 « Reply #12 on: October 28, 2009, 08:33:04 PM »

Excellent, Dave! Thanks for that info. With the correct formula for testing root validity, the standard chaos method works, but I was right about it needing reseeding. It also has very poor coverage by default. I was able to get fair results by boosting the runs of same and alternating choices, but less satisfactory than for the quadratic Julia.

Peter's version of MIIM using contractivity is more practical than what I read about using pixel hit counts.

I used Peter Liepa's source code to write the following short Mathematica program. It seems to be working correctly:
imax = 100; z = Table[0, {imax}]; dz = Table[1, {imax}]; roots = Table[1, {imax}];
power = 2; zc = -0.74543 + 0.11301I; x1 = -1.5; y1 = -1.5; x2 = 1.5; y2 = 1.5; n = 275; image = Table[0, {n}, {n}]; i = 2;
While[i > 1, z[[ i ]] = If[roots[[ i ]] == 1, 1, -1]Sqrt[z[[i - 1]] - zc]; dz[[ i ]] = power Abs[z[[ i ]]]^(power - 1)dz[[i - 1]]; {x, y} = Round[n {(Re[z[[ i ]]] - x1)/(x2 - x1), (Im[z[[ i ]]] - y1)/(y2 - y1)}]; If[1 <= x <= n && 1 <= y <= n, image[[y, x]] = 1]; If[i < imax && dz[[ i ]] < 1000.0, i++; roots[[ i ]] =1, While[i > 1 && roots[[ i ]] == power, roots[[ i ]] =1; i--]; roots[[ i ]]++]];
ListDensityPlot[image, Mesh -> False, Frame -> False]

I tried to modify the code to create a Glynn Julia set but unfortunately I don't think it looks right (see image below):
CPow[z_, n_, k_] := Module[{theta = n(Arg[z] + 2Pi k)}, Abs[z]^n(Cos[theta] + I Sin[theta])];
imax = 1000; z = Table[0, {imax}]; dz = Table[1, {imax}]; roots = Table[1, {imax}];
power = 1.5; zc = -0.2; nroot = 3; n = 275; image = Table[0, {n}, {n}];
{x1, y1} = {-1.5, -1.5}; {x2, y2} = {1.5, 1.5}; i = 2; count = 0;
While[i > 1 && count < 500000, z[[ i ]] = CPow[z[[ i - 1]] - zc, 1/power, roots[[ i ]] - 1]; dz[[ i ]] = Abs[power]Abs[z[[ i ]]]^(power - 1)dz[[ i - 1]]; If[i < imax && dz[[ i ]] < 1.0*^10, i++; roots[[ i ]] = 1, {x, y} = Round[n {(Re[z[[ i ]]] - x1)/(x2 - x1), (Im[z[[ i ]]] - y1)/(y2 - y1)}]; If[1 <= x <= n && 1 <= y <= n, image[[y, x]]++]; While[i > 1 && roots[[ i ]] == nroot, roots[[ i ]] = 1; i--]; roots[[ i ]]++]; count++];
ListDensityPlot[Map[If[ # == 0, -1, Log[ # ]] &, image, {2}], Mesh -> False, Frame -> False, PlotRange -> {-1, 8}]

Do you have any thoughts about what I am doing wrong here?
 Glynn-inverse.jpg (25.95 KB, 276x276 - viewed 2221 times.) « Last Edit: October 29, 2009, 02:57:13 AM by bugman » Logged
bugman
Conqueror

Posts: 122

 « Reply #13 on: October 28, 2009, 08:34:16 PM »

Excellent, Dave! Thanks for that info. With the correct formula for testing root validity, the standard chaos method works, but I was right about it needing reseeding. It also has very poor coverage by default. I was able to get fair results by boosting the runs of same and alternating choices, but less satisfactory than for the quadratic Julia.

Peter's version of MIIM using contractivity is more practical than what I read about using pixel hit counts.

You might also want to check out Michael Becker's inverse Julia sets:
http://www.ijon.de/mathe/julia/some_julia_sets_1_en.html
http://www.ijon.de/mathe/julia/some_julia_sets_2_en.html
http://www.ijon.de/mathe/julia/some_julia_sets_3_en.html
http://www.ijon.de/mathe/julia/some_julia_sets_4_en.html

He is using an interesting hybrid method. I still am not sure exactly how it works, but I'll try to share it here if he grants permission.
 Logged
xenodreambuie
Conqueror

Posts: 124

 « Reply #14 on: October 28, 2009, 11:48:21 PM »

I tried to modify the code to create a Glynn Julia set but unfortunately I don't think it looks right (see image below):

I don't see an image, and I don't use Mathematica, but I can guess. For fractional powers, checking the validity of roots is crucial, and for power less than 2 the seed point is also crucial. The number of branches is ceil(abs(power)), and the validity has to be checked for each point.

A seed of (-1,0) works, but (-0.61,0) is much cleaner. I don't know if there's a way to calculate optimal seeds for abitrary powers (or arbitrary functions in general), so I've found it useful to add the ability to adjust the seed interactively. I had fun searching for stable sets with power -1.2.
 Logged

Regards, Garth
http://xenodream.com
 Pages: [1] 2 3 ... 5   Go Down