Logo by stardust4ever - Contribute your own Logo!
News: Did you know ? you can use LaTex inside Postings on fractalforums.com!
 
*
Welcome, Guest. Please login or register. April 23, 2017, 07:48:01 PM


Login with username, password and session length



Pages: [1] 2 3 ... 5   Go Down
  Print  
Share this topic on DiggShare this topic on FacebookShare this topic on GoogleShare this topic on RedditShare this topic on StumbleUponShare this topic on Twitter
Author Topic: Glynn Julia set  (Read 18591 times)
0 Members and 1 Guest are viewing this topic.
gamma
Safarist
******
Posts: 81



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

Hello everybody.   cheesy
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



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

Here's the parameter file so you be the judge...

* My Fractals.upr (2.06 KB - downloaded 362 times.)
Logged
bib
Global Moderator
Fractal Senior
******
Posts: 2070


At the borders...


100008697663777 @bib993
WWW
« 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.

<a href="http://www.youtube.com/v/yXgILclQXgY&rel=1&fs=1&hd=1" target="_blank">http://www.youtube.com/v/yXgILclQXgY&rel=1&fs=1&hd=1</a>
Logged

Between order and disorder reigns a delicious moment. (Paul ValÚry)
gamma
Safarist
******
Posts: 81



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

Great demo  wink
Aren't there serial keys for old versions for free?

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: 117



WWW
« 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



WWW
« 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: 117



WWW
« 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



WWW
« 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.  angel
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: 117



WWW
« 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: 2283



Makin' Magic Fractals
WWW
« 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
jtree stuff is all about.


I'm not sure whether anything of this is useful.  Your best bet would be to
get inverse iteration working to your satisfaction for the classic quadratic
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 lifetime ;
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 ;
}
}

In a follow-up reply he added:

----------------------
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: 117



WWW
« 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: 2283



Makin' Magic Fractals
WWW
« 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



WWW
« 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 815 times.)
« Last Edit: October 29, 2009, 02:57:13 AM by bugman » Logged
bugman
Conqueror
*******
Posts: 122



WWW
« 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: 117



WWW
« 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
  Print  
 
Jump to:  

Related Topics
Subject Started by Replies Views Last post
Just another julia Images Showcase (Rate My Fractal) Unhooked 3 1298 Last post May 19, 2010, 03:11:42 PM
by Bent-Winged Angel
burn buggy glynn Images Showcase (Rate My Fractal) yv3 0 702 Last post January 13, 2011, 08:23:40 PM
by yv3
Did Julia know how a Julia set looked like? Mandelbrot & Julia Set bib 7 1462 Last post February 11, 2013, 11:38:20 AM
by bib
Plaster Glynn fractal Images Showcase (Rate My Fractal) MichaelWGioffredi 1 262 Last post August 28, 2015, 12:22:14 AM
by Chillheimer
Plaster Glynn fractal Mandelbulb3D Gallery MichaelWGioffredi 0 237 Last post August 28, 2015, 08:24:03 PM
by MichaelWGioffredi

Powered by MySQL Powered by PHP Powered by SMF 1.1.21 | SMF © 2015, Simple Machines

Valid XHTML 1.0! Valid CSS! Dilber MC Theme by HarzeM
Page created in 0.316 seconds with 28 queries. (Pretty URLs adds 0.018s, 2q)