numz 0.0.3 → 0.2.0

package/docs/src/content/docs/reference/signal/functions/sequences/nums.md

@@ -0,0 +1,17 @@
+---
+title: nums
+description: nums
+sidebar : 
+    order: 2
+---
+## Definition 
+
+## Signature 
+```ts
+nums(num : number, n : number) : number[]
+```
+## Usage
+
+```ts
+const z = nums(1.5, 10) // [1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5]
+```

package/docs/src/content/docs/reference/signal/functions/sequences/ones.md

@@ -0,0 +1,19 @@
+---
+title: ones
+description: ones
+sidebar : 
+    order: 1
+---
+## Definition 
+
+## Signature
+
+```ts
+ones(n : number) : number[]
+```
+
+## Usage
+
+```ts
+const z = ones(10) // [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+```

package/docs/src/content/docs/reference/signal/functions/sequences/zeros.md

@@ -0,0 +1,20 @@
+---
+title: zeros
+description: zeros
+sidebar: 
+    order : 0
+---
+
+## Defintion
+
+## Signature
+
+```ts
+zeros(n : number) : []number
+```
+
+## Usage
+
+```ts
+const z = zeros(10) // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+```

package/docs/src/content/docs/reference/stats/accum/accum-max.md

@@ -0,0 +1,4 @@
+---
+title: accum_max
+description: accum_max
+---

package/docs/src/content/docs/reference/stats/accum/accum-min.md

@@ -0,0 +1,4 @@
+---
+title: accum_min
+description: accum_min
+---

package/docs/src/content/docs/reference/stats/accum/accum-prod.md

@@ -0,0 +1,4 @@
+---
+title: accum_prod
+description: accum_prod
+---

package/docs/src/content/docs/reference/stats/accum/accum-sum.md

@@ -0,0 +1,4 @@
+---
+title: accum_sum
+description: accum_sum
+---

package/docs/src/content/docs/reference/stats/averages/contraharmonic-mean.md

@@ -0,0 +1,4 @@
+---
+title: ch_mean
+description: contraharmonic mean
+---

package/docs/src/content/docs/reference/stats/averages/geo_mean.md

@@ -0,0 +1,6 @@
+---
+title: geo_mean
+description: geo_mean
+sidebar : 
+    order: 1
+---

package/docs/src/content/docs/reference/stats/averages/harmonic_mean.md

@@ -0,0 +1,4 @@
+---
+title: har_mean
+description: har_mean
+---

package/docs/src/content/docs/reference/stats/averages/iq-mean.md

@@ -0,0 +1,4 @@
+---
+title: iq_mean
+description: iq_mean
+---

package/docs/src/content/docs/reference/stats/averages/mean.md

@@ -0,0 +1,6 @@
+---
+title: mean
+description: mean
+sidebar : 
+    order: 0
+---

package/docs/src/content/docs/reference/stats/averages/midhinge.md

@@ -0,0 +1,4 @@
+---
+title: midhinge
+description: midhinge
+---

package/docs/src/content/docs/reference/stats/averages/midrange.md

@@ -0,0 +1,4 @@
+---
+title: midrange
+description: midrange
+---

package/docs/src/content/docs/reference/stats/averages/power_mean.md

@@ -0,0 +1,4 @@
+---
+title: pow_mean
+description: accum_prod
+---

package/docs/src/content/docs/reference/stats/averages/rms.md

@@ -0,0 +1,12 @@
+---
+title: rms
+description: rms
+sidebar : 
+    order: 2
+---
+
+
+# 11
+
+
+## 22

package/docs/src/content/docs/reference/stats/averages/trimmed_mean.md

@@ -0,0 +1,4 @@
+---
+title: trim_mean
+description: trim_mean
+---

package/docs/src/content/docs/reference/stats/averages/weighted_mean.md

@@ -0,0 +1,4 @@
+---
+title: w_mean
+description: weighted mean
+---

package/docs/src/content/docs/reference/stats/averages/winsorized_mean.md

@@ -0,0 +1,4 @@
+---
+title: win_mean
+description: win_mean
+---

package/docs/src/content.config.ts

@@ -0,0 +1,7 @@
+import { defineCollection } from 'astro:content';
+import { docsLoader } from '@astrojs/starlight/loaders';
+import { docsSchema } from '@astrojs/starlight/schema';
+
+export const collections = {
+	docs: defineCollection({ loader: docsLoader(), schema: docsSchema() }),
+};

package/docs/src/styles/custom.css

@@ -0,0 +1,21 @@
+:root {
+  --sl-content-width: 50rem;
+  --sl-text-5xl: 3.5rem;
+}
+
+h1{
+    color : darkblue;
+    /* text-decoration: 2px underline blueviolet;
+    text-decoration-skip-ink: auto; */
+    /* border-bottom: 1px red solid; */
+}
+p a{
+    color: blueviolet;
+    text-decoration: none;
+    &:hover{
+        text-decoration: underline;
+    }
+}
+/* strong{
+    color: blueviolet;
+} */

package/docs/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "include": [".astro/types.d.ts", "**/*"],
+  "exclude": ["dist"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numz",
-  "version": "0.0.3",
+  "version": "0.2.0",
   "description": "scientific computing with zikojs",
   "main": "index.js",
   "type": "module",
@@ -29,6 +29,6 @@
     "rollup": "^4.24.0"
   },
   "dependencies": {
-    "ziko": "^0.54.4"
+    "ziko": "^0.57.0"
   }
 }

package/src/calculus/derivative/index.js

@@ -0,0 +1,16 @@
+export const derivative = (f, x, h = 1e-8) => (f(x + h) - f(x - h)) / (2 * h);
+export const derivative_n = (f, x, n = 1, h = 1e-8) => {
+    if (n === 0) return f(x);
+    const df = (x0) => derivative(f, x0, h);
+    return derivative_n(df, x, n - 1, h);
+};
+
+
+export const partial_derivative = (f, vars, varIndex, h = 1e-8) => {
+    const x1 = [...vars]; 
+    const x2 = [...vars];
+    x1[varIndex] += h; 
+    x2[varIndex] -= h;
+    return (f(...x1) - f(...x2)) / (2 * h);
+};
+export const gradient = (f, vars, h = 1e-8) => vars.map((_, i) => partial_derivative(f, vars, i, h));

package/src/calculus/index.js

@@ -0,0 +1,22 @@
+export * from './derivative/index.js'
+export * from './integral/index.js'
+import { factorial } from "../discret";
+export const taylor_series = (f, x0, n=5, h=1e-5) => {
+    let sum=0;
+    for(let i=0;i<=n;i++){
+        sum += derivative_n(f,x0,i,h) / factorial(i)*(x0**i);
+    }
+    return sum;
+};
+
+export const newton_raphson = (f, x0, tol=1e-8, maxIter=100) => {
+    let x=x0;
+    for(let i=0;i<maxIter;i++){
+        const fx=f(x), dfx=derivative(f,x);
+        if(Math.abs(dfx)<1e-12) break;
+        const dx=fx/dfx;
+        x-=dx;
+        if(Math.abs(dx)<tol) break;
+    }
+    return x;
+};

package/src/calculus/integral/index.js

@@ -0,0 +1,21 @@
+export const integral_simpson = (f, a, b, n=1000) => {
+    if(n%2===1) n+=1;
+    const h=(b-a)/n;
+    let s=f(a)+f(b);
+    for(let i=1;i<n;i++){
+        s+=f(a+i*h)*(i%2===0?2:4);
+    }
+    return s*h/3;
+};
+export const integral_trapezoid = (f, a, b, n=1000) => {
+    const h=(b-a)/n;
+    let s=(f(a)+f(b))/2;
+    for(let i=1;i<n;i++) s+=f(a+i*h);
+    return s*h;
+};
+export const integral_midpoint = (f, a, b, n=1000)=>{
+    const h=(b-a)/n;
+    let s=0;
+    for(let i=0;i<n;i++) s+=f(a+(i+0.5)*h);
+    return s*h;
+};

package/src/discret/bitwise/index.js

@@ -0,0 +1,34 @@
+
+
+export const bitmasks = (n) => {
+  const res = [];
+  for (let i = 0; i < 1 << n; i++) {
+    const mask = [];
+    for (let j = 0; j < n; j++) mask.push((i >> j) & 1);
+    res.push(mask);
+  }
+  return res;
+};
+export const subsets_by_mask = (arr) => {
+  const n = arr.length,
+    res = [];
+  for (let i = 0; i < 1 << n; i++) {
+    const subset = [];
+    for (let j = 0; j < n; j++) if ((i >> j) & 1) subset.push(arr[j]);
+    res.push(subset);
+  }
+  return res;
+};
+export const gray_code = (n) => {
+  if (n === 0) return [0];
+  const prev = gray_code(n - 1);
+  return [...prev, ...prev.map((x) => x | (1 << (n - 1)))];
+};
+export const hamming_weight = (x) => {
+  let count = 0;
+  while (x) {
+    x &= x - 1;
+    count++;
+  }
+  return count;
+};

package/src/discret/combination/index.js

@@ -0,0 +1,86 @@
+export const combinations = (arr, repetition = false) => {
+  const n = arr.length,
+    result = [];
+  if (!repetition) {
+    const back = (start, cur) => {
+      if (cur.length) result.push([...cur]);
+      for (let i = start; i < n; i++) {
+        cur.push(arr[i]);
+        back(i + 1, cur);
+        cur.pop();
+      }
+    };
+    back(0, []);
+    return result;
+  }
+  const back = (start, cur) => {
+    if (cur.length) result.push([...cur]);
+    for (let i = start; i < n; i++) {
+      cur.push(arr[i]);
+      back(i, cur);
+      cur.pop();
+    }
+  };
+  back(0, []);
+  return result;
+};
+
+
+
+export const k_combinations = (arr, k, repetition = false) => {
+  const n = arr.length,
+    result = [];
+  if (!repetition) {
+    const back = (start, cur) => {
+      if (cur.length === k) result.push([...cur]);
+      else
+        for (let i = start; i < n; i++) {
+          cur.push(arr[i]);
+          back(i + 1, cur);
+          cur.pop();
+        }
+    };
+    back(0, []);
+    return result;
+  }
+  const back = (start, cur) => {
+    if (cur.length === k) result.push([...cur]);
+    else
+      for (let i = start; i < n; i++) {
+        cur.push(arr[i]);
+        back(i, cur);
+        cur.pop();
+      }
+  };
+  back(0, []);
+  return result;
+};
+
+export const multiset_combinations = (arr, k) => {
+  const counter = {},
+    unique = [];
+  for (const x of arr) {
+    if (!counter[x]) {
+      counter[x] = 0;
+      unique.push(x);
+    }
+    counter[x]++;
+  }
+  const result = [];
+  const back = (i, cur, remaining) => {
+    if (cur.length === k) {
+      result.push([...cur]);
+      return;
+    }
+    if (i >= unique.length) return;
+    const u = unique[i],
+      max_use = Math.min(counter[u], k - cur.length);
+    for (let use = 0; use <= max_use; use++) {
+      for (let j = 0; j < use; j++) cur.push(u);
+      back(i + 1, cur, remaining - use);
+      for (let j = 0; j < use; j++) cur.pop();
+    }
+  };
+  back(0, [], k);
+  return result;
+};

package/src/discret/index-dep.js

@@ -0,0 +1,110 @@
+// ==========================================
+// Discrete Mathematics / Combinatorics
+// ==========================================
+// ------------------------------
+// Binomial & Multichoose
+// ------------------------------
+export const binomial = (n, k) => {
+  if (n !== Math.floor(n) || k !== Math.floor(k))
+    return TypeError("n,k must be integers");
+  if (k < 0 || k > n) return 0;
+  k = Math.min(k, n - k);
+  let r = 1;
+  for (let i = 1; i <= k; i++) r = (r * (n - (k - i))) / i;
+  return r;
+};
+export const comb_repetition = (n, k) => binomial(n + k - 1, k);
+export const multichoose = comb_repetition;
+
+// Comb // Perm
+export const power_set = (arr) => {
+  const n = arr.length,
+    result = [];
+  for (let i = 0; i < 1 << n; i++) {
+    const subset = [];
+    for (let j = 0; j < n; j++) if ((i >> j) & 1) subset.push(arr[j]);
+    result.push(subset);
+  }
+  return result;
+};
+
+export const cartesian = (...sets) => {
+  let result = [[]];
+  for (const set of sets) {
+    const temp = [];
+    for (const x of result) for (const y of set) temp.push([...x, y]);
+    result = temp;
+  }
+  return result;
+};
+
+// ------------------------------
+// Counting / Sequences
+// ------------------------------
+export const derangement = (n) => {
+  if (n !== Math.floor(n)) return TypeError("n must be integer");
+  let r = 1;
+  for (let i = 1; i <= n; i++) {
+    r = i * r + (i % 2 === 0 ? 1 : -1);
+  }
+  return Math.round(r / Math.E);
+};
+
+export const catalan = (n) => binomial(2 * n, n) / (n + 1);
+
+export const stirling2 = (n, k) => {
+  if (k < 0 || k > n) return 0;
+  let S = Array(k + 1).fill(0);
+  S[0] = 1;
+  for (let i = 1; i <= n; i++)
+    for (let j = k; j > 0; j--) S[j] = j * S[j] + S[j - 1];
+  return S[k];
+};
+
+export const bell = (n) => {
+  let B = [1];
+  for (let i = 1; i <= n; i++) {
+    B[i] = 0;
+    for (let j = 0; j < i; j++) B[i] += binomial(i - 1, j) * B[j];
+  }
+  return B[n];
+};
+
+export const lah = (n, k) => {
+  if (n < 0 || k < 0 || k > n) return 0;
+  return (binomial(n - 1, k - 1) * factorial(n)) / factorial(k);
+};
+
+// // Eulerian numbers: number of permutations with exactly k ascents
+export const eulerian = (n,k)=>{
+  if(k<0||k>=n) return 0;
+  let dp=[Array(k+2).fill(0)];
+  dp[0][0]=1;
+  for(let i=1;i<=n;i++){
+    const ndp=Array(k+2).fill(0);
+    for(let j=0;j<=Math.min(i-1,k);j++){
+      ndp[j]= (i-j)*dp[i-1]?[j]??0:
+      ndp[j+1]= (j+1)*dp[i-1][j];
+    }
+    dp=ndp;
+  } 
+  return dp[k];
+};
+
+// Partition numbers
+export const partition_number = (n) => {
+  if (n === 0) return 1;
+  let p = [1];
+  for (let i = 1; i <= n; i++) {
+    let s = 0;
+    for (let k = 1; ; k++) {
+      let j1 = i - (k * (3 * k - 1)) / 2;
+      let j2 = i - (k * (3 * k + 1)) / 2;
+      if (j1 < 0 && j2 < 0) break;
+      if (j1 >= 0) s += (k % 2 === 0 ? -1 : 1) * p[j1];
+      if (j2 >= 0) s += (k % 2 === 0 ? -1 : 1) * p[j2];
+    }
+    p.push(s);
+  }
+  return p[n];
+};

package/src/discret/index.js

@@ -0,0 +1,4 @@
+export * from './combination/index.js'
+export * from './permutation/index.js'
+export * from './sequences'
+export * from './bitwise'

package/src/discret/permutation/index.js

@@ -0,0 +1,89 @@
+export const permutations = (arr, repetition = false) => {
+  const n = arr.length,
+    result = [];
+  if (repetition) {
+    const back = (cur) => {
+      if (cur.length === n) result.push([...cur]);
+      else
+        for (let i = 0; i < n; i++) {
+          cur.push(arr[i]);
+          back(cur);
+          cur.pop();
+        }
+    };
+    back([]);
+    return result;
+  }
+  const back = (cur, used) => {
+    if (cur.length === n) result.push([...cur]);
+    else
+      for (let i = 0; i < n; i++) {
+        if (used[i]) continue;
+        used[i] = true;
+        cur.push(arr[i]);
+        back(cur, used);
+        cur.pop();
+        used[i] = false;
+      }
+  };
+  back([], Array(n).fill(false));
+  return result;
+};
+
+
+export const k_permutations = (arr, k, repetition = false) => {
+  const n = arr.length,
+    result = [];
+  if (repetition) {
+    const back = (cur) => {
+      if (cur.length === k) result.push([...cur]);
+      else
+        for (let i = 0; i < n; i++) {
+          cur.push(arr[i]);
+          back(cur);
+          cur.pop();
+        }
+    };
+    back([]);
+    return result;
+  }
+  const back = (cur, used) => {
+    if (cur.length === k) result.push([...cur]);
+    else
+      for (let i = 0; i < n; i++) {
+        if (used[i]) continue;
+        used[i] = true;
+        cur.push(arr[i]);
+        back(cur, used);
+        cur.pop();
+        used[i] = false;
+      }
+  };
+  back([], Array(n).fill(false));
+  return result;
+};
+
+export const multiset_permutations = (arr) => {
+  const result = [],
+    counter = {};
+  for (const x of arr) counter[x] = (counter[x] || 0) + 1;
+  const unique = Object.keys(counter);
+  const n = arr.length;
+  const back = (cur) => {
+    if (cur.length === n) {
+      result.push([...cur]);
+      return;
+    }
+    for (const u of unique) {
+      if (counter[u] > 0) {
+        cur.push(u);
+        counter[u]--;
+        back(cur);
+        cur.pop();
+        counter[u]++;
+      }
+    }
+  };
+  back([]);
+  return result;
+};

package/src/discret/sequences/index.js

@@ -0,0 +1,30 @@
+export const factorial = (n) => {
+  if (n < 0 || n !== Math.floor(n))
+    return TypeError("n must be non-negative integer");
+  let r = 1;
+  for (let i = 2; i <= n; i++) r *= i;
+  return r;
+};
+export const double_factorial = (n) => {
+  if (n < 0 || n !== Math.floor(n))
+    return TypeError("n must be non-negative integer");
+  let r = 1;
+  for (let i = n; i > 1; i -= 2) r *= i;
+  return r;
+};
+export const falling = (n, k) => {
+  if (n !== Math.floor(n) || k !== Math.floor(k))
+    return TypeError("n,k must be integers");
+  if (k < 0) return 0;
+  let r = 1;
+  for (let i = 0; i < k; i++) r *= n - i;
+  return r;
+};
+export const rising = (n, k) => {
+  if (n !== Math.floor(n) || k !== Math.floor(k))
+    return TypeError("n,k must be integers");
+  if (k < 0) return 0;
+  let r = 1;
+  for (let i = 0; i < k; i++) r *= n + i;
+  return r;
+};

package/src/index.js

@@ -1 +1,6 @@
-export * from './stats/index.js'
+export * from './ufunc/index.js'
+export * from './calculus/index.js'
+export * from './signal/index.js'
+export * from './stats/index.js'
+
+