@cloudglides/nox 1.1.6 → 3.0.0

package/README.md

@@ -5,13 +5,13 @@ Simple, unpredictable random number generator.
 ## Install
 
 ```bash
-npm install nox
+npm install @cloudglides/nox
 ```
 
 ## Quick Start
 
 ```javascript
-import { rng, deterministic } from 'nox';
+import { rng, deterministic } from '@cloudglides/nox';
 
 const r = rng();
 
@@ -31,7 +31,7 @@ r.bools(5);         // [true, false, true, ...]
 ## Reproducible
 
 ```javascript
-import { deterministic } from 'nox';
+import { deterministic } from '@cloudglides/nox';
 
 const r = deterministic(42);
 // Always same sequence
@@ -40,7 +40,7 @@ const r = deterministic(42);
 ## Distributions
 
 ```javascript
-import { rng, normal, exponential, uniform, poisson } from 'nox';
+import { rng, normal, exponential, uniform, poisson } from '@cloudglides/nox';
 
 const r = rng();
 
@@ -53,7 +53,7 @@ poisson(r, lambda=5);
 ## Sampling
 
 ```javascript
-import { rng, shuffle, pick, sample } from 'nox';
+import { rng, shuffle, pick, sample } from '@cloudglides/nox';
 
 const r = rng();
 
@@ -65,7 +65,7 @@ sample([1, 2, 3, 4, 5], 3, r);
 ## State
 
 ```javascript
-import { rng, saveState, restoreState } from 'nox';
+import { rng, saveState, restoreState } from '@cloudglides/nox';
 
 const r = rng();
 const snapshot = saveState(r);
@@ -78,7 +78,7 @@ r.nextFloat(); // Same value
 ## Weighted Sampling
 
 ```javascript
-import { rng, weightedPick, reservoirSample } from 'nox';
+import { rng, weightedPick, reservoirSample } from '@cloudglides/nox';
 
 const r = rng();
 const items = ['A', 'B', 'C'];
@@ -91,7 +91,7 @@ reservoirSample(stream, k, r);          // Sample k from large stream
 ## Statistical Tests
 
 ```javascript
-import { rng, meanTest, varianceTest, kolmogorovSmirnovTest } from 'nox';
+import { rng, meanTest, varianceTest, kolmogorovSmirnovTest } from '@cloudglides/nox';
 
 const r = rng();
 const data = r.floats(1000);
@@ -106,7 +106,7 @@ const ks = kolmogorovSmirnovTest(data); // Test uniform distribution
 For reproducible results or specific generator properties:
 
 ```javascript
-import { RNG, PCG64, MT19937, Xorshift64, Splitmix64 } from 'nox';
+import { RNG, PCG64, MT19937, Xorshift64, Splitmix64 } from '@cloudglides/nox';
 
 const r = new RNG(PCG64, seed);      // PCG64 (default, fast, high quality)
 const r = new RNG(MT19937, seed);    // MT19937 (Mersenne Twister)

package/example/package.json

@@ -9,7 +9,7 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@cloudglides/nox": "^1.1.3",
+    "@cloudglides/nox": "workspace:*",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },

package/example/src/App.css

@@ -26,11 +26,34 @@ header p {
   font-size: 0.95rem;
 }
 
+.tabs-container {
+  padding: 1.5rem 2rem;
+  border-bottom: 1px solid #eee;
+  max-width: 1200px;
+  margin: 0 auto;
+  width: 100%;
+}
+
+.category {
+  margin-bottom: 1.5rem;
+}
+
+.category:last-child {
+  margin-bottom: 0;
+}
+
+.category h3 {
+  font-size: 0.9rem;
+  font-weight: 600;
+  color: #666;
+  margin: 0 0 0.6rem 0;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
 .tabs {
   display: flex;
   gap: 0.5rem;
-  padding: 1.5rem 2rem;
-  border-bottom: 1px solid #eee;
   flex-wrap: wrap;
 }
 
@@ -39,7 +62,7 @@ header p {
   border: 1px solid #000;
   background: #fff;
   cursor: pointer;
-  font-size: 0.9rem;
+  font-size: 0.85rem;
   font-weight: 500;
   transition: 0.15s;
 }
@@ -56,7 +79,7 @@ header p {
 .content {
   flex: 1;
   padding: 2rem;
-  max-width: 600px;
+  max-width: 800px;
   margin: 0 auto;
   width: 100%;
 }
@@ -84,7 +107,7 @@ header p {
 
 .result-row .label {
   font-weight: 600;
-  min-width: 110px;
+  min-width: 140px;
   color: #333;
 }
 
@@ -118,14 +141,22 @@ footer a:hover {
     font-size: 1.8rem;
   }
   
-  .tabs {
+  .tabs-container {
     padding: 1rem;
+  }
+
+  .category h3 {
+    font-size: 0.8rem;
+    margin-bottom: 0.4rem;
+  }
+  
+  .tabs {
     gap: 0.3rem;
   }
   
   .tabs button {
     padding: 0.4rem 0.8rem;
-    font-size: 0.85rem;
+    font-size: 0.75rem;
   }
   
   .content {

package/example/src/App.jsx

@@ -1,5 +1,24 @@
 import { useState } from 'react'
-import { rng, deterministic, normal, exponential } from '@cloudglides/nox'
+import {
+  rng, deterministic, normal, exponential, poisson, uniform,
+  shuffle, sample, pick, weightedPick,
+  meanTest, varianceTest, kolmogorovSmirnovTest,
+  cohensD, correlation, cramersV,
+  bootstrapCI, meanCI,
+  tTest, welchTTest, oneWayAnova,
+  LinearRegression, MultipleRegression,
+  diff, lag, sma, ema, acf,
+  matrixAdd, matrixMul, determinant, matrixInverse,
+  trapezoidal, simpsons, numericalDerivative,
+  LinearInterpolator, CubicSplineInterpolator,
+  bisection, newtonRaphson, brent,
+  rk4,
+  svd, qr, cholesky,
+  zscore, standardize, minMaxScale,
+  sum, mean, min, max, unique,
+  dirichlet, mixture,
+  gradientDescent, adam
+} from '@cloudglides/nox'
 import './App.css'
 
 const FORMAT = (n) => typeof n === 'number' ? n.toFixed(4) : n
@@ -8,7 +27,7 @@ export default function App() {
   const [results, setResults] = useState(null)
 
   const handlers = {
-    basic: () => {
+    basics: () => {
       const r = rng()
       setResults({
         title: 'Basic Operations',
@@ -16,60 +35,344 @@ export default function App() {
           ['nextFloat', FORMAT(r.nextFloat())],
           ['int(1-100)', r.int(1, 100)],
           ['bool(0.5)', r.bool(0.5) ? 'true' : 'false'],
-          ['choice', r.choice(['⚡', '🎲', '✨', '🔮'])]
+          ['choice', r.choice(['A', 'B', 'C', 'D'])],
+          ['range(1-10, step 2)', r.range(1, 10, 2).join(', ')]
         ]
       })
     },
 
-    batch: () => {
+    distributions: () => {
       const r = rng()
+      const normals = Array.from({length: 5}, () => FORMAT(normal(r)))
+      const exponentials = Array.from({length: 5}, () => FORMAT(exponential(r)))
+      const dir = dirichlet(r, [1, 2, 3]).map(FORMAT)
       setResults({
-        title: 'Batch Operations',
+        title: 'Distributions',
         data: [
-          ['floats(10)', r.floats(10).map(FORMAT).join(', ')],
-          ['ints(10, 100)', r.ints(10, 100).join(', ')],
-          ['bools(10)', r.bools(10).join(', ')]
+          ['normal(5)', normals.join(', ')],
+          ['exponential(5)', exponentials.join(', ')],
+          ['poisson(λ=3)', [poisson(r, 3), poisson(r, 3), poisson(r, 3)].join(', ')],
+          ['dirichlet[1,2,3]', dir.join(', ')]
         ]
       })
     },
 
-    distributions: () => {
+    sampling: () => {
       const r = rng()
+      const arr = [1, 2, 3, 4, 5]
+      const weights = [0.1, 0.2, 0.3, 0.2, 0.2]
       setResults({
-        title: 'Distributions',
+        title: 'Sampling Methods',
         data: [
-          ['normal(5)', Array.from({length: 5}, () => FORMAT(normal(r))).join(', ')],
-          ['exponential(5)', Array.from({length: 5}, () => FORMAT(exponential(r))).join(', ')]
+          ['shuffle', shuffle(arr, r).join(', ')],
+          ['sample(3)', sample(arr, 3, r).join(', ')],
+          ['pick', pick(arr, r)],
+          ['weightedPick', weightedPick(arr, weights, r)],
+          ['unique', unique([1, 2, 2, 3, 3, 3]).join(', ')]
         ]
       })
     },
 
-    deterministic: () => {
-      const r1 = deterministic(42)
-      const r2 = deterministic(42)
+    statistics: () => {
+      const r = rng()
+      const data = r.floats(100).map(x => x * 10)
+      const mean_val = mean(data)
+      const std = Math.sqrt(data.reduce((s, x) => s + (x - mean_val) ** 2, 0) / data.length)
+      
+      const data2 = r.floats(50).map(x => x * 8)
+      const d = cohensD(data, data2)
+      const corr = correlation(data.slice(0, 50), data2.slice(0, 50))
+      
       setResults({
-        title: 'Deterministic (seed=42)',
+        title: 'Statistics & Effect Sizes',
         data: [
-          ['sequence 1', r1.floats(5).map(FORMAT).join(', ')],
-          ['sequence 2', r2.floats(5).map(FORMAT).join(', ')],
-          ['identical', 'YES ✓']
+          ['mean', FORMAT(mean_val)],
+          ['min', FORMAT(min(data))],
+          ['max', FORMAT(max(data))],
+          ["Cohen's d", FORMAT(d)],
+          ['correlation', FORMAT(corr)],
+          ['KS-test', FORMAT(kolmogorovSmirnovTest(data.map(x => x / 10)))]
+        ]
+      })
+    },
+
+    hypothesis: () => {
+      const r = rng()
+      const group1 = r.floats(30).map(x => 5 + x * 2)
+      const group2 = r.floats(30).map(x => 5.5 + x * 2)
+      
+      const t_result = tTest(group1, group2)
+      const w_result = welchTTest(group1, group2)
+      
+      const groups = [group1, group2]
+      const anova = oneWayAnova(groups)
+      
+      setResults({
+        title: 'Hypothesis Testing',
+        data: [
+          ['t-test (t, df)', `${FORMAT(t_result.t)}, ${t_result.df}`],
+          ["Welch's t-test", FORMAT(w_result.t)],
+          ['ANOVA (F, df)', `${FORMAT(anova.f)}, ${anova.dfB}/${anova.dfW}`],
+          ['meanCI(group1)', `[${FORMAT(meanCI(group1, 1).lower)}, ${FORMAT(meanCI(group1, 1).upper)}]`]
+        ]
+      })
+    },
+
+    regression: () => {
+      const x = [1, 2, 3, 4, 5]
+      const y = [2.1, 3.9, 6.2, 7.8, 10.1]
+      
+      const model = new LinearRegression(x, y)
+      
+      const xMulti = [[1, 2], [2, 3], [3, 4], [4, 5]]
+      const yMulti = [2, 5, 9, 13]
+      const modelMulti = new MultipleRegression(xMulti, yMulti)
+      
+      setResults({
+        title: 'Regression Models',
+        data: [
+          ['Linear: slope', FORMAT(model.slope)],
+          ['Linear: intercept', FORMAT(model.intercept)],
+          ['Linear: R²', FORMAT(model.rSquared)],
+          ['Linear: RMSE', FORMAT(model.rmse)],
+          ['Multiple R²', FORMAT(modelMulti.rSquared)],
+          ['Multiple adj-R²', FORMAT(modelMulti.adjRSquared)]
+        ]
+      })
+    },
+
+    timeseries: () => {
+      const r = rng()
+      const ts = Array.from({length: 20}, (_, i) => 10 + i * 0.5 + (r.nextFloat() - 0.5) * 2)
+      
+      const diffed = diff(ts, 1)
+      const lagged = lag(ts, 2).slice(2)
+      const sma_vals = sma(ts, 3).filter(x => x !== null)
+      const ema_vals = ema(ts, 3)
+      const acf_vals = acf(ts, 5)
+      
+      setResults({
+        title: 'Time Series Analysis',
+        data: [
+          ['original (first 5)', ts.slice(0, 5).map(FORMAT).join(', ')],
+          ['diff(order=1)', diffed.slice(0, 5).map(FORMAT).join(', ')],
+          ['SMA(window=3)', sma_vals.slice(0, 5).map(FORMAT).join(', ')],
+          ['EMA(window=3)', ema_vals.slice(0, 5).map(FORMAT).join(', ')],
+          ['ACF (lag 0-2)', acf_vals.slice(0, 3).map(FORMAT).join(', ')]
+        ]
+      })
+    },
+
+    matrix: () => {
+      const A = [[1, 2], [3, 4]]
+      const B = [[5, 6], [7, 8]]
+      
+      const sum = matrixAdd(A, B)
+      const prod = matrixMul(A, B)
+      const det = determinant(A)
+      const inv = matrixInverse(A)
+      
+      setResults({
+        title: 'Matrix Operations',
+        data: [
+          ['A+B[0][0]', FORMAT(sum[0][0])],
+          ['A*B[0][0]', FORMAT(prod[0][0])],
+          ['det(A)', FORMAT(det)],
+          ['inv(A)[0][1]', FORMAT(inv[0][1])],
+          ['trace(A)', FORMAT(1 + 4)]
+        ]
+      })
+    },
+
+    decomposition: () => {
+      const A = [[1, 2], [3, 4]]
+      
+      const {U, S, VT} = svd(A, 10)
+      const {Q, R} = qr(A)
+      
+      try {
+        const L = cholesky([[4, 2], [2, 3]])
+        setResults({
+          title: 'Matrix Decompositions',
+          data: [
+            ['SVD S[0]', FORMAT(S[0])],
+            ['SVD S[1]', FORMAT(S[1])],
+            ['QR R[0][0]', FORMAT(R[0][0])],
+            ['QR R[0][1]', FORMAT(R[0][1])],
+            ['Cholesky L[0][0]', FORMAT(L[0][0])],
+            ['Cholesky L[1][0]', FORMAT(L[1][0])]
+          ]
+        })
+      } catch {
+        setResults({
+          title: 'Matrix Decompositions',
+          data: [
+            ['SVD S[0]', FORMAT(S[0])],
+            ['QR R[0][0]', FORMAT(R[0][0])],
+            ['Cholesky', 'Not positive definite']
+          ]
+        })
+      }
+    },
+
+    integration: () => {
+      const f = (x) => Math.sin(x)
+      const a = 0, b = Math.PI
+      
+      const trap = trapezoidal(f, a, b, 100)
+      const simp = simpsons(f, a, b, 100)
+      const deriv1 = numericalDerivative(f, 1)
+      const deriv2 = numericalDerivative(Math.cos, 0)
+      
+      setResults({
+        title: 'Numerical Integration & Derivatives',
+        data: [
+          ['∫sin(x) [0,π] exact', '2.0000'],
+          ['∫sin(x) trapezoidal', FORMAT(trap)],
+          ['∫sin(x) Simpson', FORMAT(simp)],
+          ['d/dx sin(x) at x=1', FORMAT(deriv1)],
+          ['d/dx cos(x) at x=0', FORMAT(deriv2)]
+        ]
+      })
+    },
+
+    interpolation: () => {
+      const x = [0, 1, 2, 3, 4]
+      const y = [0, 1, 4, 9, 16]
+      
+      const linear = new LinearInterpolator(x, y)
+      const cubic = new CubicSplineInterpolator(x, y)
+      
+      const x_interp = 1.5
+      const y_linear = linear.evaluate(x_interp)
+      const y_cubic = cubic.evaluate(x_interp)
+      
+      setResults({
+        title: 'Interpolation',
+        data: [
+          ['x points', x.join(', ')],
+          ['y points', y.join(', ')],
+          [`Linear at x=${x_interp}`, FORMAT(y_linear)],
+          [`Cubic spline at x=${x_interp}`, FORMAT(y_cubic)],
+          ['Expected (x²) at 1.5', FORMAT(1.5 * 1.5)]
+        ]
+      })
+    },
+
+    rootfinding: () => {
+      const f = (x) => x ** 2 - 4
+      const df = (x) => 2 * x
+      
+      const bisect = bisection(f, 1, 3, 1e-6)
+      const newton = newtonRaphson(f, df, 3, 1e-6)
+      const brentResult = brent(f, 1, 3, 1e-6)
+      
+      setResults({
+        title: 'Root Finding Methods',
+        data: [
+          ['f(x) = x² - 4, root is x=2'],
+          ['bisection: root', FORMAT(bisect.root)],
+          ['bisection: iterations', bisect.iterations],
+          ['Newton-Raphson: root', FORMAT(newton.root)],
+          ['Newton-Raphson: iterations', newton.iterations],
+          ['Brent: root', FORMAT(brentResult.root)],
+          ['Brent: iterations', brentResult.iterations]
+        ]
+      })
+    },
+
+    ode: () => {
+      const dydt = (t, y) => -y
+      const y0 = 1
+      const result = rk4(dydt, y0, 0, 2, 0.1)
+      
+      const analytical = Math.exp(-2)
+      
+      setResults({
+        title: 'ODE Solver (dy/dt = -y, y(0)=1)',
+        data: [
+          ['Solver method', 'RK4 (4th order)'],
+          ['Time steps', result.t.length],
+          ['t values', result.t.slice(0, 5).map(FORMAT).join(', ')],
+          ['y values', result.y.slice(0, 5).map(FORMAT).join(', ')],
+          ['y(2) numerical', FORMAT(result.y[result.y.length - 1])],
+          ['y(2) analytical', FORMAT(analytical)]
+        ]
+      })
+    },
+
+    transforms: () => {
+      const r = rng()
+      const data = r.floats(20).map(x => x * 10 + 5)
+      
+      const z = zscore(data)
+      const std = standardize(data)
+      const scaled = minMaxScale(data)
+      
+      setResults({
+        title: 'Data Transformations',
+        data: [
+          ['original: mean', FORMAT(mean(data))],
+          ['original: min', FORMAT(min(data))],
+          ['original: max', FORMAT(max(data))],
+          ['z-score: mean', FORMAT(mean(z).toFixed(10))],
+          ['z-score: std', FORMAT(Math.sqrt(z.reduce((s, x) => s + x * x, 0) / z.length))],
+          ['minmax: min', FORMAT(min(scaled))],
+          ['minmax: max', FORMAT(max(scaled))]
+        ]
+      })
+    },
+
+    optimization: () => {
+      const f = (x) => (x - 3) ** 2 + 2
+      const df = (x) => 2 * (x - 3)
+      
+      const gd = gradientDescent(f, df, 0, 0.1, 100, 1e-6)
+      const adamResult = adam(f, df, 0, 0.1, 100, 0.9, 0.999, 1e-8, 1e-6)
+      
+      setResults({
+        title: 'Optimization Methods',
+        data: [
+          ['Minimize: f(x) = (x-3)² + 2, min at x=3'],
+          ['Gradient Descent x', FORMAT(gd.x)],
+          ['Gradient Descent iterations', gd.iterations],
+          ['Gradient Descent value', FORMAT(gd.value)],
+          ['Adam x', FORMAT(adamResult.x)],
+          ['Adam iterations', adamResult.iterations],
+          ['Adam value', FORMAT(adamResult.value)]
         ]
       })
     }
   }
 
+  const categoryGroups = {
+    'Core': ['basics', 'distributions', 'sampling'],
+    'Statistics': ['statistics', 'hypothesis'],
+    'Modeling': ['regression', 'timeseries'],
+    'Numerics': ['integration', 'interpolation', 'rootfinding', 'ode'],
+    'Linear Algebra': ['matrix', 'decomposition'],
+    'Advanced': ['optimization', 'transforms']
+  }
+
   return (
     <div className="app">
       <header>
         <h1>nox</h1>
-        <p>Fast RNG with multiple algorithms</p>
+        <p>Comprehensive RNG and Numerical Computing Library</p>
       </header>
 
-      <div className="tabs">
-        {Object.keys(handlers).map(key => (
-          <button key={key} onClick={handlers[key]}>
-            {key.charAt(0).toUpperCase() + key.slice(1)}
-          </button>
+      <div className="tabs-container">
+        {Object.entries(categoryGroups).map(([category, items]) => (
+          <div key={category} className="category">
+            <h3>{category}</h3>
+            <div className="tabs">
+              {items.map(key => (
+                <button key={key} onClick={handlers[key]}>
+                  {key.charAt(0).toUpperCase() + key.slice(1).replace(/([A-Z])/g, ' $1')}
+                </button>
+              ))}
+            </div>
+          </div>
         ))}
       </div>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudglides/nox",
-  "version": "1.1.6",
+  "version": "3.0.0",
   "description": "Unpredictable random number generator with multiple algorithms and distributions",
   "type": "module",
   "main": "src/index.js",
@@ -12,6 +12,10 @@
       "default": "./src/index.js"
     }
   },
+  "scripts": {
+    "test": "node test/basic.js",
+    "bench": "node test/benchmark.js"
+  },
   "keywords": [
     "random",
     "rng",
@@ -21,11 +25,8 @@
   ],
   "author": "",
   "license": "ISC",
+  "packageManager": "pnpm@10.24.0",
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "test": "node test/basic.js",
-    "bench": "node test/benchmark.js"
   }
-}
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - '.'
+  - 'example'

package/src/core.browser.js

@@ -1,10 +1,43 @@
 export { rng, RNG } from './rng.browser.js';
 export { deterministic } from './presets.browser.js';
 
-export { normal, exponential, uniform, poisson } from './utils/distributions.js';
-export { shuffle, pick, sample } from './utils/sequence.js';
+export { normal, exponential, uniform, poisson, normals, exponentials } from './utils/distributions.js';
+export { beta, gamma, chi2, binomial, geometric } from './utils/distributions-extra.js';
+export { weibull, lognormal, rayleigh, cauchy } from './utils/distributions-special.js';
+export { dirichlet, dirichlets, mixture, mixtures, studentT, studentTs, betaBinomial } from './utils/distributions-advanced.js';
+export { shuffle, pick, sample, sampleWithReplacement, permute, range, cycle } 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';
-
+export { meanTest, varianceTest, kolmogorovSmirnovTest, chiSquareTest, entropy, autocorrelation, runTest, skewness, kurtosis, median, quantile } from './utils/statistics.js';
 export { combined, clearCryptoCache } from './utils/entropy.browser.js';
+export { brownianMotion, ornsteinUhlenbeck, geometricBrownian } from './utils/stochastic.js';
+export { categorical, multinomial, categorical2D } from './utils/categorical.js';
+export { perlin2D, valueNoise } from './utils/noise.js';
+export { combinations, permutations, kPermutations, randomCombination, randomPermutation } from './utils/combinatorics.js';
+export { rotateBits, extractBits, hammingWeight, bitRange, popcountNum, clz, ctz, reverseBits, setBit, clearBit, toggleBit } from './utils/bits.js';
+export { SeedSequence, seedMultiple } from './utils/seeding.js';
+export { seedFromTime, seedFromEntropy } from './utils/seed.js';
+export { repeat, until, times } from './utils/helpers.js';
+export { bootstrap, jackknife, crossValidation, permutationTest } from './utils/resampling.js';
+export { stratifiedSample, stratifiedSampleProportional, stratify } from './utils/stratified.js';
+export { cdf, ppf, sf } from './utils/probability.js';
+export { WeightedDistribution, CategoricalDistribution, NormalDistribution } from './utils/precomputed.js';
+export { bootstrapCI, meanCI, proportionCI } from './utils/confidence.js';
+export { cohensD, hedgesG, correlation, cramersV, etaSquared, glasssDelta } from './utils/effects.js';
+export { sum, mean, min, max, unique, chunk, flatten, zip, transpose, partition } from './utils/arrays.js';
+export { tTest, welchTTest, mannWhitneyU, oneWayAnova } from './utils/hypothesis.js';
+export { zscore, standardize, minMaxScale, logTransform, sqrtTransform, rank, robustScale } from './utils/transforms.js';
+export { LinearRegression, MultipleRegression } from './utils/regression.js';
+export { diff, lag, shift, sma, ema, acf, pacf } from './utils/timeseries.js';
+export { matrixAdd, matrixSub, matrixMul, elementwiseMul, scalarMul, determinant, trace, norm, inverse as matrixInverse } from './utils/matrix.js';
+export { trapezoidal, simpsons, adaptiveSimpson, gaussQuadrature, numericalDerivative, numericalSecondDerivative } from './utils/integration.js';
+export { LinearInterpolator, CubicSplineInterpolator, lagrangeInterpolation, polynomialFit } from './utils/interpolation.js';
+export { bisection, newtonRaphson, secant, falsePosition, fixedPoint } from './utils/rootfinding.js';
+export { eulerMethod, rk4, systemEuler, systemRK4, rk45Adaptive } from './utils/odesolvers.js';
+export { svd, qr, cholesky, lu } from './utils/decomposition.js';
+export { gradientDescent, momentumDescent, adam, simplex, brent } from './utils/optimization.js';
+export { tTestPValue, zTestPValue, fTestPValue, chi2PValue, uTestPValue, pearsonPValue } from './utils/pvalues.js';
+export { residualDiagnostics, leverageValues, cookDistance, durwinWatson, vif } from './utils/diagnostics.js';
+export { LogisticRegression } from './utils/logistic.js';
+export { PolynomialRegression } from './utils/polynomial.js';
+export { KMeans } from './utils/clustering.js';