Hi,
Is there an efficient way to plot bifurcation diagrams for
one-dimensional difference equations, where the map is generated
numerically ( as in, it is not possible to generate explicity the rule
x(n+1)= f(x(n)) ) ? In my case, I have a code which generates the
(n+1)th state given the nth state.
Here is what I used to do for say something like say, the logistic
map:
1. Fix the parameter value.
2. Take an initial condition and iterate till you remove the transients,
say after 'p' iterations.
3. Now, iterate further thereby generating the steady state solutions.
One might have to iterate a large no. of times after the 'p'th iteration
to get a bifurcation diagram which is not 'coarse'. If the parameter
value is such that only the single period orbit is stable, then all
iterations after 'p' will yield the same value. After the first
bifurcation, I will get two states if you iterate after the 'p'th
iteration. Already, the method is looking inefficient as I am having to
iterate a large no. of times (after the 'p'th iteration), even for
parameter values where the steady state is only a single-period orbit.
Is there any way to get around this rather brute-force method ? One
might say that for the logistic map, you can analytically determine the
parameter values at which the bifurcations occur (at least for the first
few bifurcations) and can reduce the iterations (after the 'p'th
iteration) depending on which parameter range you are operating in. But
that is precisely my point. What if the system is too complicated for
analytic calculation ? Worse, you don't even have an explicit rule.
Surely, there must be cases where it is not possible to generate maps
explicitly and one has to resort to a numerical way to do it. For my
system, I am having memory problems if I do it by the above method. Any
help is appreciated.