Use L64X128MixRandom in the financial benchmark Monte Carlo sample

monteCarlo() drew its normals from java.util.Random.nextGaussian(), whose
atomic seed update and StrictMath polar method dominated the inner loop.
The JDK 17+ L64X128MixRandom makes the method about 3x faster on JDK 21;
seeded runs remain reproducible, but produce different paths than before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: robertlazarski

modules/samples/userguide/src/userguide/springbootdemo-tomcat11/src/main/java/userguide/springboot/webservices/FinancialBenchmarkService.java

@@ -28,8 +28,9 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Random;
 import java.util.UUID;
+import java.util.random.RandomGenerator;
+import java.util.random.RandomGeneratorFactory;
 
 /**
  * Java reference implementation of the Axis2/C Financial Benchmark Service.
@@ -302,17 +303,25 @@ public PortfolioVarianceResponse portfolioVariance(PortfolioVarianceRequest requ
      *   and should be preserved verbatim in any re-implementation.
      *
      * <p>Sampling behavior:
-     *   Uses {@link Random#nextGaussian()} (polar method) for normal variates.
-     *   When {@code randomSeed != 0}, a seeded {@link Random} is used for
-     *   reproducibility (same seed → bit-identical output).  When
+     *   Uses the JDK 17+ {@code L64X128MixRandom} generator
+     *   ({@link RandomGenerator#nextGaussian()}, modified ziggurat) for
+     *   normal variates.  When {@code randomSeed != 0}, a seeded instance is
+     *   used for reproducibility (same seed → bit-identical output).  When
      *   {@code randomSeed == 0}, a fresh unseeded instance gives
      *   non-deterministic results.
      *
-     *   Warning for cross-implementation reproducibility: {@code java.util.Random}
-     *   uses a linear congruential generator (LCG).  An implementation in a
-     *   different language or using a different PRNG (e.g., xorshift128+,
-     *   PCG64, NumPy's default) will produce DIFFERENT numbers for the
-     *   SAME seed.  Reproducibility is per-PRNG, not cross-PRNG.
+     *   Do not switch back to {@code java.util.Random}: its
+     *   {@code nextGaussian()} updates an atomic seed on every draw and uses
+     *   the {@code StrictMath} polar method, and with ~252 draws per path it
+     *   dominates the loop.  Measured on JDK 21, swapping it for
+     *   {@code L64X128MixRandom} made this method about 3x faster on both an
+     *   Intel Xeon and an AMD EPYC server, with VaR unchanged within Monte
+     *   Carlo error.
+     *
+     *   Warning for cross-implementation reproducibility: an implementation
+     *   in a different language or using a different PRNG (e.g.,
+     *   xorshift128+, PCG64, NumPy's default) will produce DIFFERENT numbers
+     *   for the SAME seed.  Reproducibility is per-PRNG, not cross-PRNG.
      *
      * <p>Numerical edge cases:
      *   - <b>Guarded in the body below:</b> the variance accumulator
@@ -401,9 +410,10 @@ public MonteCarloResponse monteCarlo(MonteCarloRequest request)
         double volSqrtDt = sigma * Math.sqrt(dt);
 
         // ── PRNG: seeded for reproducibility, unseeded for production ─────────
-        Random rng = request.getRandomSeed() != 0
-            ? new Random(request.getRandomSeed())
-            : new Random();
+        // L64X128MixRandom, not java.util.Random — see "Sampling behavior" above.
+        RandomGenerator rng = request.getRandomSeed() != 0
+            ? RandomGeneratorFactory.of("L64X128MixRandom").create(request.getRandomSeed())
+            : RandomGenerator.of("L64X128MixRandom");
 
         logger.info(logPrefix + "starting " + nSims + " sims × " + nPeriods + " periods" +
                 " (seed=" + request.getRandomSeed() + ", npy=" + npy + ")");

modules/samples/userguide/src/userguide/springbootdemo-tomcat11/src/main/java/userguide/springboot/webservices/MonteCarloRequest.java

@@ -79,7 +79,7 @@
  *
  * <h3>Reproducibility</h3>
  * <p>Setting a non-zero {@code randomSeed} makes the run deterministic
- * AGAINST THIS IMPLEMENTATION (Java {@link java.util.Random}).  The same
+ * AGAINST THIS IMPLEMENTATION (the JDK's {@code L64X128MixRandom}).  The same
  * seed will not produce the same output under other PRNGs — xorshift128+,
  * PCG64, Mersenne Twister, NumPy's Generator — so seeded reproducibility
  * is per-backend, not cross-backend.  Callers comparing VaR numbers
@@ -162,7 +162,7 @@ public class MonteCarloRequest {
     /**
      * Random seed for reproducibility. 0 (default) → non-deterministic
      * (each call yields different results). A non-zero value seeds
-     * {@link java.util.Random} so repeated calls with the same seed give
+     * the JDK's {@code L64X128MixRandom} so repeated calls with the same seed give
      * bit-identical output.
      *
      * <p>Cross-PRNG caveat: the same seed in a different language or PRNG