Function Graph
Function:Number of points:Minimum x value:Maximum x value:Plot button: |
Bifurcation Diagram \lambda, and the vertical coordinate
is the value of y=u(0).
Dimension N: Number of points:Numerical mesh length:Initial point (x_0):Plot button: |

- Widening your browser for better view of both painting areas!
- Click and drag a rectangle in the either diagrams to zoom in the graph. But to get a better view of graph, change the Minimum and Maximum value of x for function, see the last tip.
- The Function Graph responds very fast, so put whatever options for all entries, but the function must be in right format.
- The Bifurcation Diagram responds slower. With the default parameter, it takes about 5 seconds for repainting in a Pentium 133 PC. But considering this is a much more comlicated graph (in fact, it is the mechanism behind the graph more comlicated), such waiting time is still durable ?
- Changing the Dimension or initial point will generally do not affect the responding speed, but they do affect the accuracy of the graph.
- Changing the Number of Points parameter will affect the responding time. More time for more points, but the time increasing is linear, so if you think it is worthing that you wait 20 seconds for 500 points, then try it !
- The worst thing is to change the Numerical mesh of computation parameter, say, from 0.01 to 0.001 or even 0.0001. Though it will result in much better accuracy of the graph, but it may take minutes of waiting, even the machine will stuck. So for accuracy of data, we have an alternate way.
- The Bifurcation Diagram will only plot the points whose y value is on the x value of Function Graph, so choose the Minimum and Maximum value of x for function, and get desired diagram.

(1)

where *\lambda* is a positive parameter. This boundary value problem
is reduced from a semilinear elliptic equation:

(2)

*\Delta
u+\lambda f(u)=0, in \Omega,*
*
u=0,
on \partial \Omega,*

where *\Omega* is the unit ball in **R ^{n}**

is always radially symmetric, if

An important property of equation (1) is that,
for any *d>0*, there is at most one *\lambda(d)>0* such that
(1)

has a positive solution *u *with *\lambda =\lambda(d) *
and *u(0)=d.*

Let

T={d>0 : (1) has a positive solution with u(0)=d },

then *T* is an open subset of **R ^{+}**;

We call

{(\lambda (d), d): (1) has a solution with u(0)=d, \lambda=\lambda (d)} the

and the phase space with bifurcation curve the

**Exact Multiplicity of positive solutions of
a class of semilinear problems**

**Exact Multiplicity of positive solutions of
a class of semilinear problems: II**

and the many references therein. But all these
rigorous results are still very restrictive. For example, the curve with
multiple turning points is verturally unsolvable for most case. So numerical
calculation is a good way to get dependable information for some problems
which you can never solve. Following are some suggestions for your numerical
experiments:

Instead of considering (1), we acturally solve an initial value problem:

(3)

*u''+(n-1)/r *u'+f(u)=0,
r > 0*
*
u'(0)=0, u(0)=u_0.*

Notice that the new equation does not contain parameter \lambda. We use Runge-Kutta method to solve equation (3), we can get the values of u(r), u'(r) at each point r(k)=k*h+u_0, where k is a positive integer, h is the number which you input as "Numerical mesh" and u_0 is the initial height, aslong as u(r)>0.

The shooting method is simple: if for some k>0, u(r(k))>0 and u(r(k+1))<0, then we stop shooting, and return the value R=r(k). Then we rescale the equation (3), let \lambda(u_0)=R*R, then we get a solution of (1). The pair (\lambda(u_0), u_0) is a point which we will actrually plot on the Bifurcation Diagram.

At this point, I have not discussed the convergence of this algorithm. It seems to be OK for most cases, even with not too small mesh size and not too many plotting points. But obviously, it fails when the value of u_0 is getting too large. I believe that there is a converge range of x_0, with given maximum error, mesh-size and initial point x_0. I hope I can theoriotically prove it later.

If you want fast response of the applet, then you must have a trade-off between the computation-time and the accuracy of the diagram. For a better data set of (\lambda, u), we also implement the above algorithm in C++, which will result in a file containing the data set. With this program, we can take a longer time to get better result: for example, you can set the mesh size to be 0.0001 or even 0.00001, and computing with u_0 increasing each 0.01 or less. For u_0 from 0 to 20, this may take 10 minutes or so in a PC. The good part of the C++ program is

- We can know the Morse index of each solution, which is also outputed.
- We can get the data of sign-changing solutions, with the number of sign-changing inputed by the user.
- The program is interactive, except the function, all other parameters are inputed when the program is executed.

http://www.sci.usq.edu.au/staff/leighb/graph/classes/ . All the source provided is covered by the GNU General Public Licence.

My source code of the bifurcation diagram is as follows:

BifurGraph.java Equation.java Apoint.java

and the programs provided by Leigh Brookshaw are

parse1d.java and the graph package .

This document was first writen by Junping Shi in Feb. 13th, 1998.