Marsaglia Normal Random Variables in C++ - c++

Question

My query is pretty simple. I prefer to code numerical methods in Java but often need to do some things in C++. I like the Gaussian random variable in Java since it uses the Marsaglia algorithm AND keeps both Normal random variables. It returns one on the first call, the second on the second call, and does not do the expensive calculations again until the third call. Using the oracle link below (in program comments) I tried to implement this code in C++ but don't know how to write the C++ version of the "Synchronized" Public Method that will allow me to make use of both Normal random variables. I am not a professional programmer, so any guidance would be greatly appreciated.
In short I would like to keep:
v2*multiplier
// This function is Similar to the GNU
// Java Implementation as seen on
// http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Random.html#nextGaussian%28%29
double nextGaussian() {
double v1, v2, s, nextNextGaussian;
do {
v1 = 2 * nextUniform() - 1; // between -1.0 and 1.0
v2 = 2 * nextUniform() - 1; // between -1.0 and 1.0
s = v1 * v1 + v2 * v2;
} while (s >= 1 || s == 0);
double multiplier = sqrt(-2 * log(s)/s);
nextNextGaussian = v2 * multiplier;
return v1 * multiplier;
}

Answer 1

Just declare nextGaussianVal as static, i.e.
static double nextGaussianVal;
Then the value of nextGaussianVal will be available the next time the method is called. You might also need another static variable to keep up with the current count, like so:
double nextGaussian()
{
static int count = 0;
static double nextGaussianVal;
double firstGaussianVal, v1, v2, s;
if (count == 0) {
do {
v1 = 2 * nextUniform() - 1; // between -1.0 and 1.0
v2 = 2 * nextUniform() - 1; // between -1.0 and 1.0
s = v1 * v1 + v2 * v2;
} while (s >= 1 || s == 0);
double multiplier = sqrt(-2 * log(s)/s);
nextGaussianVal = v2 * multiplier;
firstGaussianVal = v1 * multiplier;
count = 1;
return firstGaussianVal;
}
count = 0;
return nextGaussianVal;
}
Edit: A more detailed explanation -- the first time the function is called, count is initialized to zero. Based on the if statement, the calculation in question is performed, and it is assumed that firstGaussianVal and nextGaussianVal are assigned values, count is assigned a value of one, and firstGaussianVal is returned. The next time the function is called, count will have its previously assigned value of one, and nextGaussianVal will contain the value it was previously assigned during the first call -- that being said, since count is now one, the function will, based on the if statement, assign zero to count and return nextGaussianVal. Rinse, repeat...

Answer 2

In a more object-oriented matter you should keep that stuff in a "random-number-generator" object. Look for instance at this code:
https://code.cor-lab.org/projects/nemomath/repository/entry/trunk/nemomath/src/nemo/Random.h
The class "gaussian" implemented what you want to have in the algorithmic way you it to be.

Answer 3

The problem with the above suggestion is that the COUNT variable should be a BOOLEAN and not an integer. In addition the stored Gaussian needs to also be STATIC.
I want to thank everybody for their help in helping me arrive to the correct solution I desired. I am aware that this snippet belongs in an object. I have my reasons for keeping it in one file right now.
double nextGaussian() {
// Static variables allow the function to make use of
// both Gaussian Random variables. Generated by the polar Marsaglia
// method This makes the function much more efficient with will
// pay off for simulations
static bool hasNextGaussian = false;
static double nextNextGaussian;
double v1, v2, s;
if (!hasNextGaussian) {
do {
v1 = 2 * nextUniform() - 1; // between -1.0 and 1.0
v2 = 2 * nextUniform() - 1; // between -1.0 and 1.0
s = v1 * v1 + v2 * v2;
} while (s >= 1 || s == 0);
double multiplier = sqrt(-2 * log(s)/s);
nextNextGaussian = v2 * multiplier;
hasNextGaussian = true;
return v1 * multiplier;
} else {
hasNextGaussian = false;
return nextNextGaussian;
}
}
double nextUniform() {
double Uniform = rand() / double(RAND_MAX);
return Uniform;
}