guest post by David Tanzer
Last time we introduced the concept of stochastic resonance. Briefly, it’s a way that noise can amplify a signal, by giving an extra nudge that helps a system receiving that signal make the jump from one state to another. Today we’ll describe a program that demonstrates this concept. But first, check it out:
No installation required! It runs as a web page which allows you to set the parameters of the model and observe the resulting output signal. It has a responsive behavior, because it runs right in your browser, as javascript.
There are sliders for controlling the amounts of sine wave and noise involved in the mix. As explained in the previous article, when we set the wave to a level not quite sufficient to cause the system to oscillate between states, and we add in the right amount of noise, stochastic resonance should kick in:
The program implements a mathematical model that runs in discrete time. It has two stable states, and is driven by a combination of a sine forcing function and a noise source.
The code builds on top of a library called JSXGraph, which supports function plotting, interactive graphics, and data visualization.
Running the program
If you haven’t already, go try the program. On one plot it shows a sine wave, called the forcing signal, and a chaotic timeseries, called the output signal.
There are four sliders, which we’ll call Amplitude, Frequency, Noise and SamplePath.
• The Amplitude and Frequency sliders control the sine wave. Try them out.
• The output signal depends, in a complex way, on the sine wave. Vary Amplitude and Frequency to see how they affect the output signal.
• The amount of randomization involved in the process is controlled by the Noise slider. Verify this.
• Change the SamplePath slider to alter the sequence of random numbers that are fed to the process. This will cause a different instance of the process to be displayed.
Now try to get stochastic resonance to kick in…
Going to the source
Time to look at the blueprints. It’s easy.
• Open the model web page. The code is now running in your browser.
• While there, run your browser’s viewsource function. For Firefox on the Mac, click AppleU. For Firefox on the PC, click CtrlU.
• You should see the html file for the web page itself.
• See the “script” directives at the head of this file. Each one refers to javascript program on the internet. When the browser sees it, the program is fetched and loaded into the browser’s internal javascript interpreter. Here are the directives:
http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default http://cdnjs.cloudflare.com/ajax/libs/jsxgraph/0.93/jsxgraphcore.js http://./StochasticResonanceEuler.js http://./normals.js
The first one loads MathJax, which is a formularendering engine. Next comes JSXGraph, a library that provides support for plotting and interactive graphics. Next, StochchasticResonanceEuler.js is the main code for the model, and finally, normals.js provides random numbers.
• In the source window, click on the link for StochasticResonanceEuler.js — and you’ve reached the source!
Anatomy of the program
The program implements a stochastic difference equation, which defines the changes in the output signal as a function of its current value and a random noise value.
It consists of the following components:
 Interactive controls to set parameters

Plot of the forcing signal

Plot of the output signal

A function that defines a particular SDE

A simulation loop, which renders the output signal.
The program contains seven functions. The toplevel function is initCharts. It dispatches to initControls, which builds the sliders, and initSrBoard, which builds the curve objects for the forcing function and the output signal (called “position curve” in the program). Each curve object is assigned a function that computes the (x,t) values for the time series, which gets called whenever the input parameters change. The function that is assigned to the forcing curve computes the sine wave, and reads the amplitude and frequency values from the sliders.
The calculation method for the output signal is set to the function mkSrPlot, which performs the simulation. It begins by defining a function for the deterministic part of the derivative:
deriv = Deriv(t,x) = SineCurve(t) + BiStable(x),
Then it constructs a “stepper” function, through the call Euler(deriv, tStep). A stepper function maps the current point (t,x) and a noise sample to the next point (t’,x’). The Euler stepper maps
((t,x), noiseSample)
to
(t + tStep, x + tStep * Deriv(t,x) + noiseSample).
The simulation loop is then performed by the function sdeLoop, which is given:
• The stepper function
• The noise amplitude (“dither”)
• The initial point (t0,x0)
• A randomization offset
• The number of points to generate
The current point is initialized to (t0,x0), and then the stepper is repeatedly applied to the current point and the current noise sample. The output returned is the sequence of (t,x) values.
The noise samples are normally distributed random numbers stored in an array. They get scaled by the noise amplitude when they are used. The array contains more values than are needed. By changing the starting point in the array, different instances of the process are obtained.
Making your own version of the program
Now let’s tweak the program to do new things.
First let’s make a local copy of the program on your local machine, and get it to run there. Make a directory, say /Users/macbookpro/stochres. Open the html file in the view source window. Paste it into the file /Users/macbookpro/stochres/stochres.html. Next, in the view source window, click on the link to StochasticResonanceEuler.js. Paste the text into /Users/macbookpro/stochres/StochasticResonanceEuler.js.
Now point your browser to the file, with the URL file:///Users/macbookpro/stochres/stochres.html. To prove that you’re really executing the local copy, make a minor edit to the html text, and check that it shows up when you reload the page. Then make a minor edit to StochasticResonanceEuler.js, say by changing the label text on the slider from “forcing function” to “forcing signal.”
Programming exercises
Now let’s get warmed up with some bitesized programming exercises.
 Change the color of the sine wave.
Change the exponent in the bistable polynomial to values other than 2, to see how this affects the output.
Add an integervalued slider to control this exponent.
Modify the program to perform two runs of the process, and show the output signals in different colors.
Modify it to perform ten runs, and change the output signal to display the pointwise average of these ten runs.
Add an input slider to control the number of runs.
Add another plot, which shows the standard deviation of the output signals, at each point in time.
Replace the precomputed array of normally distributed random numbers with a runtime computation that uses a random number generator. Use the SamplePath slider to seed the random number generator.
When the sliders are moved, explain the flow of events that causes the recalculation to take place.
A small research project
What is the impact of the frequency of the forcing signal on its transmission through stochastic resonance?
• Make a hypothesis about the relationship.
• Check your hypothesis by varying the Frequency slider.
• Write a function to measure the strength of the output signal at the forcing frequency. Let sinwave be a discretely sampled sine wave at the forcing frequency, and coswave be a discretely sampled cosine wave. Let sindot = the dot product of sinwave and the output signal, and similarly for cosdot. Then the power measure is sindot^{2} + cosdot^{2}.
• Modify the program to perform N trials at each frequency over some specified range of frequency, and measure the average power over all the N trials. Plot the power as a function of frequency.
• The above plot required you to fix a wave amplitude and noise level. Choose five different noise levels, and plot the five curves in one figure. Choose your noise levels in order to explore the range of qualitative behaviors.
• Produce several versions of this fivecurve plot, one for each sine amplitude. Again, choose your amplitudes in order to explore the range of qualitative behaviors.
Wow! It’s amazing that you can write a program like that which not only works in the browser but is simple enough to actually modify locally. It’ll probably take me hours of fun to figure out all the puzzles though…
It is interesting, a simple script to obtain a running program in each operating system; I am thinking if it is possible to apply this system to parallel calculus in a system with different operating systems, with different processors (for example a scientific computing in a growing system of different processors).
The other application could be the minimization of a function with many relative minimum points using noiseinduce hops.
While Allan Erskine and Glyn Adgie were writing the first version of this program, Allan expressed some discomfort at writing it in Javascript. Not much numerical code is written in Javascript, I guess, and maybe this is a selfreinforcing situation. But it really seems good to have software like this that runs on a browser with no “installation” process required. How can we make this easier and more fun to do?
I think part of the reservation that some people who write numerical code have is that Javascript is designed to be quick to write rather than quick to execute. As such, it may feels like you need to write two copies of the program, one in a language with optimizationamenable semantics for serious use and one for the web in Javascript. I haven’t tried out any of these, but maybe some from this set of languages that can be converted to Javascript might turn out to be more attractive. (I suspect you can’t write just any program in the original language but have to stick to a subset, but it might still be more palatable.)