如何在 c 中为线性同余生成器 LCG 实现模数 2^64

Question

This is an implementation in C for linear congruential generator that has this formula:

X_{n+1}=a*X_{n} \\bmod m

Below are two versions of the linear congruential generator function, the first function generates a 64-bit integer number and the second one should generate a double.

The Modulus in the codes below is 2ˆ64−1. I want to rewrite the modulus to be 2^64, when I tried that I get an error because of the data type. Since 2^64 is a 65 bit and the function has a "uint64_t" data type that holds 64 bits. I looked for solutions to solve the problem like using a 128 bits data type but I am using Xcode on Mac and it does not support it, and some recommend using GPM but I don't prefer it. I thought about storing the Modulus in an array but I don't know how I can later get the final output to be a 64-bit integer.

Is there any simple way to do it? because I need the final output from the first function to be a 64-bit integer and the output from the second function to be a double, so later I can use them in further calculations.

EDIT: In the code the modulus has the value m= 18446744073709551615 that is 2ˆ64−1. I want to change that to be m= 18446744073709551616 that is 2^64. I get an error when I do that because of the data type. How I can change the modulus to be m= 18446744073709551616 = 2^64?

uint64_t linear_congruential()
   {
    uint64_t s= 1442695040888963407;// seed
    unsigned long long int m=18446744073709551615; // The Modulus 2ˆ64−1    
    uint64_t a=6364136223846793005; // the multiplier a
    s=(s * a )&m;
    return s;
    }

The second function that has double:

double linear_congruential_d()
 {
  double q;
  uint64_t s= 1442695040888963407; //seed
  unsigned long long int m=18446744073709551615; // The Modulus 2ˆ64−1
  uint64_t a=6364136223846793005 ; // the multiplier a
  s=(s * a )&m;
  q=s/m; 
  return q;
 }

Answer 1

The modulus used in these functions is not $2^{64}-1$ but $2^{64}$ .
If $x$ is a power of 2, you can always divide modulo $x$ by:

s = s*a & (x-1);

That is what is done here.

This operation is superfluous anyways here, since the result of the multiply is automatically truncated to 64 bit by cutting off the higher 64 bit of the 128 bit long result. Simplified version:

uint64_t linear_congruential()
{
    static uint64_t s= 1442695040888963407; // seed
    const uint64_t a = 6364136223846793005; // the multiplier a
    s *= a;
    return s;
}

The second function will not work. As s and m are integer, s/m will be done as integer division, that is, the result will be rounded down to the next integer. It will be (almost) always 0. Instead you should write:

q = s / (double)m;

Edit: the variable s must be made static. It has to keep its value for the next call to the function.

Answer 2

Just an aside, when converting a 64-bit unsigned integer into a double, the standard way is this:

unsigned long long my_big_number = .....;
double my_double_number = my_big_number / (double)MAX_UINT;

But this may be faster:

double my_double_number = ( static_cast<double>(my_big_number>>2) / 2.0);

That takes advantage of the IEEE double precision bit format and, if your integer is full range 64-bits, then the double will be in the range [ 0.0 .. 2.0 ) . The final dividing by 2.0 to put it the target range of [ 0.0 .. 1.0 ) will be faster than dividing by (double)MAX_INT .