@cloudglides/nox 1.0.1

package/example/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "nox-demo",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@cloudglides/nox": "latest",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.2.1",
+    "vite": "^5.0.8"
+  }
+}

package/example/src/App.css

@@ -0,0 +1,161 @@
+.app {
+  width: 100%;
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  background: linear-gradient(135deg, #1e1e2e 0%, #2d2d44 100%);
+}
+
+header {
+  padding: 3rem 2rem;
+  text-align: center;
+  border-bottom: 2px solid #646cff;
+}
+
+header h1 {
+  font-size: 3rem;
+  margin-bottom: 0.5rem;
+  background: linear-gradient(45deg, #646cff, #0ea5e9);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+header p {
+  font-size: 1.1rem;
+  color: #a0a0a0;
+}
+
+.tabs {
+  display: flex;
+  gap: 1rem;
+  padding: 2rem;
+  justify-content: center;
+  flex-wrap: wrap;
+  border-bottom: 1px solid #444;
+}
+
+.tabs button {
+  padding: 0.8rem 1.6rem;
+  font-size: 1rem;
+  border: 2px solid transparent;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: all 0.3s;
+  color: #a0a0a0;
+  background: #2d2d44;
+}
+
+.tabs button:hover {
+  color: #646cff;
+  border-color: #646cff;
+}
+
+.tabs button.active {
+  color: #fff;
+  border-color: #646cff;
+  background: #1a1a2e;
+}
+
+.content {
+  flex: 1;
+  padding: 2rem;
+  max-width: 900px;
+  margin: 0 auto;
+  width: 100%;
+}
+
+.section {
+  background: #2d2d44;
+  padding: 2rem;
+  border-radius: 12px;
+  border: 1px solid #444;
+}
+
+.section h2 {
+  margin-bottom: 1.5rem;
+  color: #646cff;
+}
+
+.action-btn {
+  background: linear-gradient(45deg, #646cff, #0ea5e9);
+  color: white;
+  padding: 0.8rem 2rem;
+  font-size: 1rem;
+  border: none;
+  border-radius: 8px;
+  cursor: pointer;
+  font-weight: 600;
+  transition: transform 0.2s, box-shadow 0.2s;
+  margin-bottom: 1.5rem;
+}
+
+.action-btn:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 10px 25px rgba(100, 108, 255, 0.3);
+}
+
+.action-btn:active {
+  transform: translateY(0);
+}
+
+.results {
+  background: #1a1a2e;
+  padding: 1.5rem;
+  border-radius: 8px;
+  border-left: 4px solid #646cff;
+  margin-top: 1rem;
+  font-family: 'Courier New', monospace;
+  word-break: break-all;
+}
+
+.results p {
+  margin: 0.8rem 0;
+  line-height: 1.6;
+}
+
+.results strong {
+  color: #646cff;
+  font-weight: 600;
+}
+
+footer {
+  text-align: center;
+  padding: 2rem;
+  border-top: 1px solid #444;
+  color: #a0a0a0;
+}
+
+footer a {
+  color: #646cff;
+  text-decoration: none;
+  margin: 0 0.5rem;
+}
+
+footer a:hover {
+  text-decoration: underline;
+}
+
+@media (max-width: 768px) {
+  header h1 {
+    font-size: 2rem;
+  }
+
+  .tabs {
+    gap: 0.5rem;
+    padding: 1rem;
+  }
+
+  .tabs button {
+    padding: 0.6rem 1rem;
+    font-size: 0.9rem;
+  }
+
+  .content {
+    padding: 1rem;
+  }
+
+  .section {
+    padding: 1.5rem;
+  }
+}

package/example/src/App.jsx

@@ -0,0 +1,176 @@
+import { useState } from 'react'
+import { rng, deterministic, normal, exponential, meanTest, varianceTest, kolmogorovSmirnovTest } from '@cloudglides/nox'
+import './App.css'
+
+export default function App() {
+  const [tab, setTab] = useState('basic')
+  const [results, setResults] = useState({})
+
+  const runBasic = () => {
+    const r = rng()
+    setResults({
+      float: r.nextFloat().toFixed(6),
+      int: r.int(1, 100),
+      bool: r.bool(0.5),
+      range: r.range(10, 20, 2),
+      choice: r.choice(['apple', 'banana', 'cherry'])
+    })
+  }
+
+  const runBatch = () => {
+    const r = rng()
+    setResults({
+      floats: r.floats(5).map(x => x.toFixed(4)).join(', '),
+      ints: r.ints(5, 100).join(', '),
+      bools: r.bools(5).join(', ')
+    })
+  }
+
+  const runDistributions = () => {
+    const r = rng()
+    const samples = r.floats(100)
+    setResults({
+      normal: Array.from({length: 5}, () => normal(r).toFixed(4)).join(', '),
+      exponential: Array.from({length: 5}, () => exponential(r).toFixed(4)).join(', ')
+    })
+  }
+
+  const runStats = () => {
+    const r = rng()
+    const data = r.floats(1000)
+    const mean = meanTest(data)
+    const variance = varianceTest(data)
+    const ks = kolmogorovSmirnovTest(data)
+    setResults({
+      mean: mean.mean.toFixed(6),
+      variance: variance.variance.toFixed(6),
+      ksPass: ks.pass_0_05 ? 'PASS' : 'FAIL'
+    })
+  }
+
+  const runDeterministic = () => {
+    const r1 = deterministic(42)
+    const seq1 = r1.floats(5)
+    const r2 = deterministic(42)
+    const seq2 = r2.floats(5)
+    setResults({
+      seq1: seq1.map(x => x.toFixed(4)).join(', '),
+      seq2: seq2.map(x => x.toFixed(4)).join(', '),
+      identical: JSON.stringify(seq1) === JSON.stringify(seq2) ? 'YES' : 'NO'
+    })
+  }
+
+  return (
+    <div className="app">
+      <header>
+        <h1>nox - RNG Demo</h1>
+        <p>Unpredictable random number generator with multiple algorithms</p>
+      </header>
+
+      <div className="tabs">
+        <button className={tab === 'basic' ? 'active' : ''} onClick={() => setTab('basic')}>
+          Basic
+        </button>
+        <button className={tab === 'batch' ? 'active' : ''} onClick={() => setTab('batch')}>
+          Batch
+        </button>
+        <button className={tab === 'distributions' ? 'active' : ''} onClick={() => setTab('distributions')}>
+          Distributions
+        </button>
+        <button className={tab === 'stats' ? 'active' : ''} onClick={() => setTab('stats')}>
+          Statistics
+        </button>
+        <button className={tab === 'deterministic' ? 'active' : ''} onClick={() => setTab('deterministic')}>
+          Deterministic
+        </button>
+      </div>
+
+      <div className="content">
+        {tab === 'basic' && (
+          <div className="section">
+            <h2>Basic RNG Operations</h2>
+            <button onClick={runBasic} className="action-btn">Run</button>
+            <div className="results">
+              {results.float && (
+                <div>
+                  <p><strong>nextFloat():</strong> {results.float}</p>
+                  <p><strong>int(1, 100):</strong> {results.int}</p>
+                  <p><strong>bool(0.5):</strong> {results.bool ? 'true' : 'false'}</p>
+                  <p><strong>range(10, 20, 2):</strong> {results.range}</p>
+                  <p><strong>choice():</strong> {results.choice}</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {tab === 'batch' && (
+          <div className="section">
+            <h2>Batch Operations</h2>
+            <button onClick={runBatch} className="action-btn">Run</button>
+            <div className="results">
+              {results.floats && (
+                <div>
+                  <p><strong>floats(5):</strong> [{results.floats}]</p>
+                  <p><strong>ints(5, 100):</strong> [{results.ints}]</p>
+                  <p><strong>bools(5):</strong> [{results.bools}]</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {tab === 'distributions' && (
+          <div className="section">
+            <h2>Statistical Distributions</h2>
+            <button onClick={runDistributions} className="action-btn">Run</button>
+            <div className="results">
+              {results.normal && (
+                <div>
+                  <p><strong>Normal(0, 1):</strong> [{results.normal}]</p>
+                  <p><strong>Exponential(1):</strong> [{results.exponential}]</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {tab === 'stats' && (
+          <div className="section">
+            <h2>Statistical Tests</h2>
+            <button onClick={runStats} className="action-btn">Run on 1000 samples</button>
+            <div className="results">
+              {results.mean && (
+                <div>
+                  <p><strong>Mean (expected 0.5):</strong> {results.mean}</p>
+                  <p><strong>Variance (expected 0.083333):</strong> {results.variance}</p>
+                  <p><strong>KS Test (α=0.05):</strong> {results.ksPass}</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {tab === 'deterministic' && (
+          <div className="section">
+            <h2>Deterministic Mode</h2>
+            <button onClick={runDeterministic} className="action-btn">Run with seed=42</button>
+            <div className="results">
+              {results.seq1 && (
+                <div>
+                  <p><strong>Sequence 1:</strong> [{results.seq1}]</p>
+                  <p><strong>Sequence 2:</strong> [{results.seq2}]</p>
+                  <p><strong>Identical:</strong> {results.identical}</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+      </div>
+
+      <footer>
+        <p>Visit <a href="https://github.com/cloudglides/nox" target="_blank" rel="noreferrer">GitHub</a> | <a href="https://npmjs.com/package/@cloudglides/nox" target="_blank" rel="noreferrer">npm</a></p>
+      </footer>
+    </div>
+  )
+}

package/example/src/index.css

@@ -0,0 +1,55 @@
+:root {
+  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+}
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+#root {
+  width: 100%;
+  min-height: 100vh;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+
+button:hover {
+  border-color: #646cff;
+}
+
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}

package/example/src/main.jsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.jsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

package/example/vite.config.js

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    rollupOptions: {
+      external: ['perf_hooks', 'crypto']
+    }
+  }
+})

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@cloudglides/nox",
+  "version": "1.0.1",
+  "description": "Unpredictable random number generator with multiple algorithms and distributions",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "exports": {
+    ".": {
+      "node": "./src/index.js",
+      "default": "./src/index.js"
+    }
+  },
+  "scripts": {
+    "test": "node test/basic.js",
+    "bench": "node test/benchmark.js"
+  },
+  "keywords": ["random", "rng", "generator", "chaotic", "stochastic"],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.24.0",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/core.js

@@ -0,0 +1,8 @@
+export { rng, RNG } from './rng.js';
+export { deterministic } from './presets.js';
+
+export { normal, exponential, uniform, poisson } from './utils/distributions.js';
+export { shuffle, pick, sample } from './utils/sequence.js';
+export { saveState, restoreState, cloneGenerator } from './utils/state.js';
+export { weightedPick, weightedSample, reservoirSample } from './utils/sampling.js';
+export { meanTest, varianceTest, kolmogorovSmirnovTest } from './utils/statistics.js';

package/src/generators/index.js

@@ -0,0 +1,7 @@
+export { Xorshift64 } from './xorshift64.js';
+export { Logistic } from './logistic.js';
+export { Tent } from './tent.js';
+export { Splitmix64 } from './splitmix64.js';
+export { PCG64 } from './pcg64.js';
+export { MT19937 } from './mt19937.js';
+export { Mixer } from './mixer.js';

package/src/generators/logistic.js

@@ -0,0 +1,19 @@
+export class Logistic {
+  constructor(seed = 0.5, r = 3.99) {
+    this.x = seed;
+    this.r = r;
+  }
+
+  next() {
+    this.x = this.r * this.x * (1 - this.x);
+    return this.x;
+  }
+
+  nextInt(max = 2147483647) {
+    return Math.floor(this.next() * max);
+  }
+
+  nextFloat() {
+    return this.next();
+  }
+}

package/src/generators/mixer.js

@@ -0,0 +1,20 @@
+export class Mixer {
+  constructor(rng1, rng2) {
+    this.rng1 = rng1;
+    this.rng2 = rng2;
+  }
+
+  next() {
+    return this.rng1.next() ^ this.rng2.next();
+  }
+
+  nextInt(max = 2147483647) {
+    const v1 = this.rng1.nextInt(max);
+    const v2 = this.rng2.nextInt(max);
+    return (v1 + v2) % max;
+  }
+
+  nextFloat() {
+    return (this.rng1.nextFloat() + this.rng2.nextFloat()) / 2;
+  }
+}

package/src/generators/mt19937.js

@@ -0,0 +1,74 @@
+export class MT19937 {
+  constructor(seed = 5489) {
+    this.N = 624;
+    this.M = 397;
+    this.MATRIX_A = 0x9908b0df;
+    this.UPPER_MASK = 0x80000000;
+    this.LOWER_MASK = 0x7fffffff;
+
+    this.mt = new Array(this.N);
+    this.mti = this.N + 1;
+
+    this.init(seed);
+  }
+
+  init(seed) {
+    const s = typeof seed === 'bigint' ? Number(seed) : seed;
+    this.mt[0] = (s >>> 0) & 0xffffffff;
+    
+    for (let i = 1; i < this.N; i++) {
+      const x = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
+      this.mt[i] = (((((x & 0xffff0000) >>> 16) * 1812433253) << 16) + (x & 0xffff) * 1812433253) + i;
+      this.mt[i] = this.mt[i] >>> 0;
+    }
+  }
+
+  twist() {
+    for (let i = 0; i < this.N - this.M; i++) {
+      const y = (this.mt[i] & this.UPPER_MASK) | (this.mt[i + 1] & this.LOWER_MASK);
+      this.mt[i] = this.mt[i + this.M] ^ (y >>> 1) ^ (y & 1 ? this.MATRIX_A : 0);
+    }
+    for (let i = this.N - this.M; i < this.N - 1; i++) {
+      const y = (this.mt[i] & this.UPPER_MASK) | (this.mt[i + 1] & this.LOWER_MASK);
+      this.mt[i] = this.mt[i + (this.M - this.N)] ^ (y >>> 1) ^ (y & 1 ? this.MATRIX_A : 0);
+    }
+    const y = (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK);
+    this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ (y & 1 ? this.MATRIX_A : 0);
+    this.mti = 0;
+  }
+
+  next() {
+    if (this.mti >= this.N) {
+      this.twist();
+    }
+
+    let y = this.mt[this.mti++];
+    y ^= y >>> 11;
+    y ^= (y << 7) & 0x9d2c5680;
+    y ^= (y << 15) & 0xefc60000;
+    y ^= y >>> 18;
+
+    return y >>> 0;
+  }
+
+  nextInt(max = 2147483647) {
+    if (max <= 0) {
+      throw new Error('max must be positive');
+    }
+    
+    const limit = Math.floor(0xffffffff / max) * max;
+    let val;
+    
+    do {
+      val = this.next();
+    } while (val >= limit);
+    
+    return val % max;
+  }
+
+  nextFloat() {
+    const a = this.next() >>> 5;
+    const b = this.next() >>> 6;
+    return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
+  }
+}

package/src/generators/pcg64.js

@@ -0,0 +1,44 @@
+export class PCG64 {
+  constructor(seed = 1n, inc = 1n) {
+    this.state = 0n;
+    this.inc = ((typeof inc === 'number' ? BigInt(inc) : inc) << 1n) | 1n;
+    this.step();
+    this.state += (typeof seed === 'number' ? BigInt(seed) : seed);
+    this.step();
+  }
+
+  step() {
+    this.state = (this.state * 6364136223846793005n + this.inc) & ((1n << 64n) - 1n);
+  }
+
+  next() {
+    const oldState = this.state;
+    this.step();
+
+    const xorShifted = ((oldState >> 18n) ^ oldState) >> 27n;
+    const rot = oldState >> 59n;
+    const result = (xorShifted >> rot) | ((xorShifted << (64n - rot)) & ((1n << 64n) - 1n));
+    
+    return result;
+  }
+
+  nextInt(max = 2147483647) {
+    if (max <= 0) {
+      throw new Error('max must be positive');
+    }
+    
+    let val = this.next() & 0x7fffffffffffffffn;
+    const limit = (0xffffffffffffffffn / BigInt(max)) * BigInt(max);
+    
+    while (val >= limit) {
+      val = this.next() & 0x7fffffffffffffffn;
+    }
+    
+    return Number(val % BigInt(max));
+  }
+
+  nextFloat() {
+    const val = this.next() & ((1n << 53n) - 1n);
+    return Number(val) / 9007199254740992.0;
+  }
+}

package/src/generators/splitmix64.js

@@ -0,0 +1,32 @@
+export class Splitmix64 {
+  constructor(seed = 1) {
+    this.state = BigInt(seed);
+  }
+
+  next() {
+    let z = (this.state += 0x9e3779b97f4a7c15n);
+    z = (z ^ (z >> 30n)) * 0xbf58476d1ce4e5b9n;
+    z = z ^ (z >> 27n);
+    return z;
+  }
+
+  nextInt(max = 2147483647) {
+    if (max <= 0) {
+      throw new Error('max must be positive');
+    }
+    
+    let val = this.next() & 0x7fffffffffffffffn;
+    const limit = (0xffffffffffffffffn / BigInt(max)) * BigInt(max);
+    
+    while (val >= limit) {
+      val = this.next() & 0x7fffffffffffffffn;
+    }
+    
+    return Number(val % BigInt(max));
+  }
+
+  nextFloat() {
+    const val = this.next() & ((1n << 53n) - 1n);
+    return Number(val) / 9007199254740992.0;
+  }
+}

package/src/generators/tent.js

@@ -0,0 +1,24 @@
+export class Tent {
+  constructor(seed = 0.5, mu = 1.95) {
+    this.x = Math.max(0.00001, Math.min(0.99999, seed));
+    this.mu = mu;
+  }
+
+  next() {
+    if (this.x < 0.5) {
+      this.x = this.mu * this.x;
+    } else {
+      this.x = this.mu * (1 - this.x);
+    }
+    this.x = Math.max(0.00001, Math.min(0.99999, this.x));
+    return this.x;
+  }
+
+  nextInt(max = 2147483647) {
+    return Math.floor(this.next() * max);
+  }
+
+  nextFloat() {
+    return this.next();
+  }
+}