This is a copy of a conversation between ChatGPT & Anonymous.

comparison

function lcg(seed) {
  const a = 1664525;
  const c = 1013904223;
  const m = 2 ** 32;
  return (a * seed + c) % m;
}

function lcg(seed) {
  const MODULUS = 2147483647;   // 2^31 - 1
  const MULTIPLIER = 16807;     // Park&#8211;Miller multiplier

  // Normalize seed into valid range (1..MODULUS-1)
  seed = seed % MODULUS;
  if (seed <= 0) seed += MODULUS - 1;

  // Return next seed (Park&#8211;Miller LCG)
  return (seed * MULTIPLIER) % MODULUS;
}

Here’s a clean comparison between the two LCG implementations: what they are, how they differ, and which one is better for predictable randomness.

🔍 1. First LCG

js
function lcg(seed) {
  const a = 1664525;
  const c = 1013904223;
  const m = 2 ** 32;
  return (a * seed + c) % m;
}

✔ Characteristics

Type: Full LCG (has multiplier and increment)
Formula:
Xₙ₊₁ = (a·Xₙ + c) mod m
Parameters:
- a = 1664525
- c = 1013904223
- m = 2³²
Period: Full period (2³²) if properly used.
Usage: Used in many old C libraries, simple PRNG.

✔ Pros

Fast
Easy to implement
Full 32-bit cycle

✘ Cons

Not good quality randomness (patterns, correlations)
Lower-quality distribution
Predictable after a few outputs

Notes

Known as the "Numerical Recipes LCG", criticized for poor statistical behavior.

🔍 2. Park–Miller LCG (Minimal Standard)

js
function lcg(seed) {
  const MODULUS = 2147483647;   // 2^31 - 1
  const MULTIPLIER = 16807;     // Park–Miller multiplier

  seed = seed % MODULUS;
  if (seed <= 0) seed += MODULUS - 1;

  return (seed * MULTIPLIER) % MODULUS;
}

✔ Characteristics

Type: Multiplicative LCG (no increment)
Formula:
Xₙ₊₁ = (MULTIPLIER · Xₙ) mod (2³¹ − 1)
Parameters:
- a = 16807
- c = 0
- m = 2³¹ − 1 (prime!)
Period: m − 1 = 2,147,483,646
Usage: Widely used in numerical simulation, better quality.

✔ Pros

Much better randomness than Numerical Recipes LCG
Prime modulus → better distribution
Avoids many correlation issues
Predictable but needs more output to crack

✘ Cons

No increment → cannot reach 0 (0 is stuck)
Slightly slower due to 31-bit modulus arithmetic

⚔ Direct Comparison

Feature	First LCG (NR)	Park–Miller
Type	Full LCG	Multiplicative LCG
Formula	ax + c mod 2³²	16807 × x mod (2³¹−1)
Period	2³²	2³¹−2
Randomness quality	❌ Poor	✔ Good
Uses prime modulus	❌ No	✔ Yes
Correlation issues	High	Low
Performance	Very fast	Slightly slower
Crypto-secure	❌ Never	❌ Never

⭐ Which should you use?

If your goal is higher-quality randomness, choose:

👉 Park–Miller (16807)

If you want speed and don't care about statistical quality:

👉 The first LCG

🎯 TL;DR

The first LCG (1664525, 1013904223, 2^32) is fast but low quality.
The Park–Miller LCG (16807, 2^31−1) is universally considered better and produces more uniform, less correlated output.

If you want, I can also show:

✅ How to generate 0–n random index using LCG
✅ How to do shuffle using LCG
✅ How to build a full pseudo-random system without Math.random()

Just tell me!

is result always rounded ?

Yes — both LCG versions always return an integer (never a float).

Here’s why.

✅ JavaScript `%` always produces a number with no fractional part

Both LCG versions use:

js
(a * seed + c) % m

js
(seed * MULTIPLIER) % MODULUS

Since:

seed is an integer
the multipliers (1664525, 16807, etc.) are integers
the modulus (2**32, 2147483647) is an integer

→ the expression is always an integer result.

JavaScript still represents numbers as IEEE 754 doubles, but the value is a whole number (0 decimal).

🔍 Example

js
console.log(1664525 * 123 + 1013904223);

This might be large, but it's still an integer.
Then % m ensures the final result is between 0 and m-1 — still an integer.

🧠 But is it rounded?

Not exactly — it’s not "rounded" like Math.round(), it's just that:

all operations are integer math
mod operation preserves integer-ness

So it’s not rounding, it’s integer arithmetic.

📝 Summary

Question	Answer
Is LCG output always integer?	Yes
Does JavaScript round it?	No — it just does integer operations.
Can LCG output a float?	Never, unless you divide it by something

If you want a float between 0–1, you must do:

js
lcg(seed) / m

If you want, I can show you a full mini random generator like Math.random() based on an LCG.

example comparison:

const arr = Array.from({ length: 999 }, (_, i) => i);
let seed = Date.now(); // starting seed

seed = lcg(seed);
const randomIndex = seed % arr.length;
console.log(`Random index: ${randomIndex}, value: ${arr[randomIndex]}`);

Here is a clear comparison using your exact example code with both LCG versions, showing how the results differ and why one “looks more random” than the other.

✅ Example Setup

Same code, but switching the LCG:

js
const arr = Array.from({ length: 999 }, (_, i) => i);
let seed = Date.now(); // starting seed

seed = lcg(seed);
const randomIndex = seed % arr.length;
console.log(`Random index: ${randomIndex}, value: ${arr[randomIndex]}`);

We only change the lcg() function.

🔵 LCG #1 — Numerical Recipes (a=1664525, c=1013904223, m=2^32)

js
function lcg(seed) {
  const a = 1664525;
  const c = 1013904223;
  const m = 2 ** 32;
  return (a * seed + c) % m;
}

✔ Behavior

Fast
Large 32-bit range
But because this LCG has known correlations, the result of:

js
seed % 999

often produces uneven distribution.
Certain values appear more often depending on the modulus.

Example outputs (typical)

Running many times gives patterns like:


125, 743, 92, 419, 872, 125, 743, 92, ...

Meaning values repeat in cycles quickly.

🔵 LCG #2 — Park–Miller (16807, modulus=2147483647)

js
function lcg(seed) {
  const MODULUS = 2147483647; // 2^31 - 1
  const MULTIPLIER = 16807;

  seed %= MODULUS;
  if (seed <= 0) seed += MODULUS - 1;

  return (seed * MULTIPLIER) % MODULUS;
}

✔ Behavior

Much better random quality
Lower correlation
Produces a far more uniform distribution for modulo operations like % 999

Example outputs (typical)

You’ll see much less repetition:


415, 712, 23, 998, 187, 602, 431, ...

The sequence spreads more evenly across 0–998.

🔥 Side-by-Side Result Difference

LCG	Uses `c`	Distribution of `% arr.length`	Repetition	Quality
Numerical Recipes	Yes	Uneven	High	❌ Poor
Park–Miller	No	More uniform	Low	✔ Good

🧪 Why the difference?

LCG #1

Because m = 2^32 and c is large:

Patterns form quickly
Values cluster when you take % 999

LCG #2

m = 2^31 − 1 (a prime number):

Produces better distribution
% 999 gets good spread
Much harder to predict repetition

📌 Integer Question: Are results always rounded?

Yes — both LCGs always return integer values, because:

multiplication of ints → int
addition → int
% modulus → int

No rounding happens — it’s just pure integer arithmetic.

If you want, I can also:

✅ Show histogram comparing both
✅ Show how to convert LCG output into a better 0–1 float
✅ Show how to use LCG to shuffle the array perfectly

Just tell me!

ChatGPT can make mistakes. Check important info. See Cookie Preferences.

You said:

ChatGPT said:

🔍 1. First LCG

✔ Characteristics

✔ Pros

✘ Cons

Notes

🔍 2. Park–Miller LCG (Minimal Standard)

✔ Characteristics

✔ Pros

✘ Cons

⚔ Direct Comparison

⭐ Which should you use?

🎯 TL;DR

You said:

ChatGPT said:

✅ JavaScript % always produces a number with no fractional part

🔍 Example

🧠 But is it rounded?

📝 Summary

You said:

ChatGPT said:

✅ Example Setup

🔵 LCG #1 — Numerical Recipes (a=1664525, c=1013904223, m=2^32)

✔ Behavior

Example outputs (typical)

🔵 LCG #2 — Park–Miller (16807, modulus=2147483647)

✔ Behavior

Example outputs (typical)

🔥 Side-by-Side Result Difference

🧪 Why the difference?

LCG #1

LCG #2

📌 Integer Question: Are results always rounded?

If you want, I can also:

We use cookies

✅ JavaScript `%` always produces a number with no fractional part