lcg64

Author: cieplypolar

apps/typegpu-docs/src/examples/tests/uniformity/constants.ts

@@ -2,7 +2,6 @@ import type { PRNGKey } from './prngs.ts';
 
 export const gridSizes = [8, 16, 32, 64, 128, 256, 512, 1024];
 export const initialGridSize = gridSizes[4];
-export const initialPRNG: PRNGKey = 'bpeter';
 export const samplesPerThread = [1, 8, 16, 64, 256, 1024, 131072, 262144];
 export const initialSamplesPerThread = samplesPerThread[0];
 export const initialTakeAverage = false;

apps/typegpu-docs/src/examples/tests/uniformity/index.ts

@@ -69,9 +69,9 @@ const computeFn = (x: number, y: number) => {
   const gridSize = configUniform.$.gridSize;
 
   if (configUniform.$.useSeed2 === 1) {
-    randf.seed2(d.vec2f(x, y));
+    randf.seed2(d.vec2f(x, y) + 1);
   } else {
-    randf.seed(d.f32(x) * gridSize + d.f32(y));
+    randf.seed(d.f32(x + 1) * gridSize + d.f32(y + 1));
   }
 
   let i = d.u32(0);
@@ -98,7 +98,7 @@ const getComputePipeline = (key: PRNGKey) => {
       .with(randomGeneratorSlot, prngs[key].generator)
       .createGuardedComputePipeline(computeFn)
       .withPerformanceCallback((start, end) => {
-        console.log(`[${key}] - ${Number(end - start) / 1000} ms.`);
+        console.log(`[${key}] - ${Number(end - start) / 1_000_000} ms.`);
       });
     computePipelineCache.set(key, pipeline);
   }

apps/typegpu-docs/src/examples/tests/uniformity/prngs.ts

@@ -1,4 +1,4 @@
-import { BPETER, LCG32, XOROSHIRO64STARSTAR, type StatefulGenerator } from '@typegpu/noise';
+import { BPETER, LCG32, LCG64, XOROSHIRO64STARSTAR, type StatefulGenerator } from '@typegpu/noise';
 
 interface PRNGOptions {
   name: string;
@@ -9,11 +9,11 @@ interface PRNGOptions {
 export const prngs = {
   bpeter: { name: 'bpeter (default)', useSeed2: true, generator: BPETER },
   lcg32: { name: 'lcg32', useSeed2: false, generator: LCG32 },
+  lcg64: { name: 'lcg64', useSeed2: true, generator: LCG64 },
   xoroshiro64: { name: 'xoroshiro64', useSeed2: true, generator: XOROSHIRO64STARSTAR },
 } as const satisfies Record<string, PRNGOptions>;
 
 export type PRNGKey = keyof typeof prngs;
 
 export const prngKeys = Object.keys(prngs) as PRNGKey[];
-
 export const initialPRNG: PRNGKey = 'bpeter';

apps/typegpu-docs/tests/individual-example-tests/uniformity.test.ts

@@ -70,10 +70,10 @@ describe('uniformity test example', () => {
       fn computeFn(x: u32, y: u32, _arg_2: u32) {
         let gridSize2 = configUniform.gridSize;
         if ((configUniform.useSeed2 == 1u)) {
-          randSeed2(vec2f(f32(x), f32(y)));
+          randSeed2((vec2f(f32(x), f32(y)) + 1f));
         }
         else {
-          randSeed(((f32(x) * gridSize2) + f32(y)));
+          randSeed(((f32((x + 1u)) * gridSize2) + f32((y + 1u))));
         }
         var i = 0u;
         let samplesPerThread = configUniform.samplesPerThread;
@@ -137,16 +137,16 @@ describe('uniformity test example', () => {
         seed_1(seed);
       }
 
-      fn u32To01Float(value: u32) -> f32 {
+      fn u32To01F32(value: u32) -> f32 {
         let mantissa = (value >> 9u);
         let bits = (1065353216u | mantissa);
         let f = bitcast<f32>(bits);
         return (f - 1f);
       }
 
       fn sample() -> f32 {
-        seed = ((seed * 1664525u) + 1013904223u);
-        return u32To01Float(seed);
+        seed = ((1664525u * seed) + 1013904223u);
+        return u32To01F32(seed);
       }
 
       fn randFloat01() -> f32 {
@@ -158,10 +158,10 @@ describe('uniformity test example', () => {
       fn computeFn(x: u32, y: u32, _arg_2: u32) {
         let gridSize2 = configUniform.gridSize;
         if ((configUniform.useSeed2 == 1u)) {
-          randSeed2(vec2f(f32(x), f32(y)));
+          randSeed2((vec2f(f32(x), f32(y)) + 1f));
         }
         else {
-          randSeed(((f32(x) * gridSize2) + f32(y)));
+          randSeed(((f32((x + 1u)) * gridSize2) + f32((y + 1u))));
         }
         var i = 0u;
         let samplesPerThread = configUniform.samplesPerThread;
@@ -211,10 +211,16 @@ describe('uniformity test example', () => {
         return x;
       }
 
+      fn rotl(x: u32, k: u32) -> u32 {
+        return ((x << k) | (x >> (32u - k)));
+      }
+
       var<private> seed: vec2u;
 
       fn seed2(value: vec2f) {
-        seed = vec2u(hash(u32(value.x)), hash(u32(value.y)));
+        let hx = hash((u32(value.x) ^ 2135587861u));
+        let hy = hash((u32(value.y) ^ 2654435769u));
+        seed = vec2u(hash((hx ^ hy)), hash((rotl(hx, 16u) ^ hy)));
       }
 
       fn randSeed2(seed: vec2f) {
@@ -225,10 +231,138 @@ describe('uniformity test example', () => {
 
       }
 
+      fn u64Mul(a: vec2u, b: vec2u) -> vec2u {
+        let all_1 = (a.x & 65535u);
+        let alh = (a.x >> 16u);
+        let ahl = (a.y & 65535u);
+        let ahh = (a.y >> 16u);
+        let bll = (b.x & 65535u);
+        let blh = (b.x >> 16u);
+        let bhl = (b.y & 65535u);
+        let bhh = (b.y >> 16u);
+        let row0_0 = (bll * all_1);
+        let row0_1 = (bll * alh);
+        let row0_2 = (bll * ahl);
+        let row0_3 = (bll * ahh);
+        let row1_0 = (blh * all_1);
+        let row1_1 = (blh * alh);
+        let row1_2 = (blh * ahl);
+        let row2_0 = (bhl * all_1);
+        let row2_1 = (bhl * alh);
+        let row3_0 = (bhh * all_1);
+        let r1 = (row0_0 & 65535u);
+        var r2 = (((row0_0 >> 16u) + (row0_1 & 65535u)) + (row1_0 & 65535u));
+        var r3 = (((((row0_1 >> 16u) + (row0_2 & 65535u)) + (row1_0 >> 16u)) + (row1_1 & 65535u)) + (row2_0 & 65535u));
+        var r4 = (((((((row0_2 >> 16u) + (row0_3 & 65535u)) + (row1_1 >> 16u)) + (row1_2 & 65535u)) + (row2_0 >> 16u)) + (row2_1 & 65535u)) + (row3_0 & 65535u));
+        r3 += (r2 >> 16u);
+        r2 &= 65535u;
+        r4 += (r3 >> 16u);
+        r3 &= 65535u;
+        r4 &= 65535u;
+        return vec2u((r1 | (r2 << 16u)), (r3 | (r4 << 16u)));
+      }
+
+      fn u64Add(a: vec2u, b: vec2u) -> vec2u {
+        let rl = (a.x + b.x);
+        let carry = u32(((rl < a.x) && (rl < b.x)));
+        let rh = ((a.y + b.y) + carry);
+        return vec2u(rl, rh);
+      }
+
+      fn u32To01F32(value: u32) -> f32 {
+        let mantissa = (value >> 9u);
+        let bits = (1065353216u | mantissa);
+        let f = bitcast<f32>(bits);
+        return (f - 1f);
+      }
+
+      fn sample() -> f32 {
+        seed = u64Add(u64Mul(seed, vec2u(1284865837, 1481765933)), vec2u(1, 0));
+        return u32To01F32(seed.y);
+      }
+
+      fn randFloat01() -> f32 {
+        return sample();
+      }
+
+      @group(1) @binding(0) var texture: texture_storage_2d<r32float, write>;
+
+      fn computeFn(x: u32, y: u32, _arg_2: u32) {
+        let gridSize2 = configUniform.gridSize;
+        if ((configUniform.useSeed2 == 1u)) {
+          randSeed2((vec2f(f32(x), f32(y)) + 1f));
+        }
+        else {
+          randSeed(((f32((x + 1u)) * gridSize2) + f32((y + 1u))));
+        }
+        var i = 0u;
+        let samplesPerThread = configUniform.samplesPerThread;
+        var samples = 0f;
+        while ((i < (samplesPerThread - 1u))) {
+          samples += randFloat01();
+          i += 1u;
+        }
+        var result = randFloat01();
+        if ((configUniform.takeAverage == 1u)) {
+          result = ((result + samples) / f32(samplesPerThread));
+        }
+        textureStore(texture, vec2u(x, y), vec4f(result, 0f, 0f, 0f));
+      }
+
+      struct mainCompute_Input {
+        @builtin(global_invocation_id) id: vec3u,
+      }
+
+      @compute @workgroup_size(16, 16, 1) fn mainCompute(in: mainCompute_Input)  {
+        if (any(in.id >= sizeUniform)) {
+          return;
+        }
+        computeFn(in.id.x, in.id.y, in.id.z);
+      }
+
+      @group(0) @binding(0) var<uniform> sizeUniform: vec3u;
+
+      struct Config {
+        gridSize: f32,
+        canvasRatio: f32,
+        useSeed2: u32,
+        samplesPerThread: u32,
+        takeAverage: u32,
+      }
+
+      @group(0) @binding(1) var<uniform> configUniform: Config;
+
+      fn hash(v: u32) -> u32 {
+        var x = (v ^ (v >> 17u));
+        x *= 3982152891u;
+        x ^= (x >> 11u);
+        x *= 2890668881u;
+        x ^= (x >> 15u);
+        x *= 830770091u;
+        x ^= (x >> 14u);
+        return x;
+      }
+
       fn rotl(x: u32, k: u32) -> u32 {
         return ((x << k) | (x >> (32u - k)));
       }
 
+      var<private> seed: vec2u;
+
+      fn seed2(value: vec2f) {
+        let hx = hash((u32(value.x) ^ 2135587861u));
+        let hy = hash((u32(value.y) ^ 2654435769u));
+        seed = vec2u(hash((hx ^ hy)), hash((rotl(hx, 16u) ^ hy)));
+      }
+
+      fn randSeed2(seed: vec2f) {
+        seed2(seed);
+      }
+
+      fn randSeed(seed_1: f32) {
+
+      }
+
       fn next() -> u32 {
         let s0 = seed[0i];
         var s1 = seed[1i];
@@ -238,7 +372,7 @@ describe('uniformity test example', () => {
         return (rotl((seed[0i] * 2654435771u), 5u) * 5u);
       }
 
-      fn u32To01Float(value: u32) -> f32 {
+      fn u32To01F32(value: u32) -> f32 {
         let mantissa = (value >> 9u);
         let bits = (1065353216u | mantissa);
         let f = bitcast<f32>(bits);
@@ -247,7 +381,7 @@ describe('uniformity test example', () => {
 
       fn sample() -> f32 {
         let r = next();
-        return u32To01Float(r);
+        return u32To01F32(r);
       }
 
       fn randFloat01() -> f32 {
@@ -259,10 +393,10 @@ describe('uniformity test example', () => {
       fn computeFn(x: u32, y: u32, _arg_2: u32) {
         let gridSize2 = configUniform.gridSize;
         if ((configUniform.useSeed2 == 1u)) {
-          randSeed2(vec2f(f32(x), f32(y)));
+          randSeed2((vec2f(f32(x), f32(y)) + 1f));
         }
         else {
-          randSeed(((f32(x) * gridSize2) + f32(y)));
+          randSeed(((f32((x + 1u)) * gridSize2) + f32((y + 1u))));
         }
         var i = 0u;
         let samplesPerThread = configUniform.samplesPerThread;

packages/typegpu-noise/src/generator.ts

@@ -1,6 +1,6 @@
 import tgpu, { d, type TgpuFnShell, type TgpuSlot } from 'typegpu';
 import { cos, dot, fract } from 'typegpu/std';
-import { hash, u32To01F32 } from './utils.ts';
+import { hash, rotl, u32To01F32, u64Add, u64Mul } from './utils.ts';
 
 export interface StatefulGenerator {
   seed?: (seed: number) => void;
@@ -56,13 +56,6 @@ export const BPETER: StatefulGenerator = (() => {
 export const XOROSHIRO64STARSTAR: StatefulGenerator = (() => {
   const seed = tgpu.privateVar(d.vec2u);
 
-  const rotl = tgpu.fn(
-    [d.u32, d.u32],
-    d.u32,
-  )((x, k) => {
-    return (x << k) | (x >> (32 - k));
-  });
-
   const next = tgpu.fn(
     [],
     d.u32,
@@ -77,7 +70,9 @@ export const XOROSHIRO64STARSTAR: StatefulGenerator = (() => {
 
   return {
     seed2: tgpu.fn([d.vec2f])((value) => {
-      seed.$ = d.vec2u(hash(d.u32(value.x)), hash(d.u32(value.y)));
+      const hx = hash(d.u32(value.x) ^ 2135587861);
+      const hy = hash(d.u32(value.y) ^ 2654435769);
+      seed.$ = d.vec2u(hash(hx ^ hy), hash(rotl(hx, 16) ^ hy));
     }),
 
     sample: randomGeneratorShell(() => {
@@ -94,34 +89,44 @@ export const XOROSHIRO64STARSTAR: StatefulGenerator = (() => {
 export const LCG32: StatefulGenerator = (() => {
   const seed = tgpu.privateVar(d.u32);
 
+  const multiplier = d.u32(1664525);
+  const increment = d.u32(1013904223);
+
   return {
     seed: tgpu.fn([d.f32])((value) => {
       seed.$ = hash(d.u32(value));
     }),
 
     sample: randomGeneratorShell(() => {
       'use gpu';
-      seed.$ = seed.$ * 1664525 + 1013904223; // % 2 ^ 32
+      seed.$ = multiplier * seed.$ + increment; // % 2 ^ 32
       return u32To01F32(seed.$);
     }).$name('sample'),
   };
 })();
 
 /**
  * Naive Linear Congruential Generator (LCG) with 64 bits state
+ * Incorporated from: https://en.wikipedia.org/wiki/Linear_congruential_generator (Musl)
  */
 export const LCG64: StatefulGenerator = (() => {
-  const seed = tgpu.privateVar(d.u32);
+  const seed = tgpu.privateVar(d.vec2u);
+
+  // 1481765933 * 2 ** 32 + 1284865837 = 6364136223846793005
+  const multiplier = d.vec2u(1284865837, 1481765933);
+  const increment = d.vec2u(1, 0);
 
   return {
-    seed: tgpu.fn([d.f32])((value) => {
-      seed.$ = d.u32(value) * 1048577;
+    seed2: tgpu.fn([d.vec2f])((value) => {
+      const hx = hash(d.u32(value.x) ^ 2135587861);
+      const hy = hash(d.u32(value.y) ^ 2654435769);
+      seed.$ = d.vec2u(hash(hx ^ hy), hash(rotl(hx, 16) ^ hy));
     }),
 
     sample: randomGeneratorShell(() => {
       'use gpu';
-      seed.$ = seed.$ * 1664525 + 1013904223; // % 2 ^ 32
-      return u32To01F32(seed.$);
+      seed.$ = u64Add(u64Mul(seed.$, multiplier), increment);
+      return u32To01F32(seed.$.y);
     }).$name('sample'),
   };
 })();