@johnhenry/math 0.0.0

package/src/Clifford4Internal.ts

@@ -0,0 +1,90 @@
+/**
+ * Internal Cl(4,0) geometric-algebra engine, used by {@link Vec4}, {@link Bivector4}
+ * and {@link Rotor4} to implement the geometric product, sandwich product, and
+ * exponential/logarithm maps correctly.
+ *
+ * Not exported from the package index — it is an implementation detail. Basis
+ * vectors e1..e4 are represented as bits 0..3 of a "blade" bitmask (0..15),
+ * e.g. blade 0b0011 = e1^e2, blade 0b1111 = e1^e2^e3^e4 (the pseudoscalar).
+ * Because the metric is Euclidean (e_i * e_i = +1 for every i — no negative or
+ * null basis vectors), the geometric product of two basis blades only needs a
+ * *reordering sign* (how many transpositions sort the concatenated index list
+ * into canonical order); there is no metric-signature contribution. This is
+ * the standard bitmask/blade technique used by geometric-algebra libraries
+ * (e.g. ganja.js), and is far less error-prone than hand-deriving each
+ * product formula term by term.
+ */
+
+export const BLADE_COUNT = 16; // 2^4 basis blades in Cl(4,0)
+
+function popcount(n: number): number {
+  let count = 0;
+  let x = n;
+  while (x !== 0) {
+    count += x & 1;
+    x >>= 1;
+  }
+  return count;
+}
+
+/** Sign picked up reordering the concatenation of blade `a` then blade `b` into canonical order. */
+function reorderingSign(a: number, b: number): number {
+  let aShifted = a >> 1;
+  let swaps = 0;
+  while (aShifted !== 0) {
+    swaps += popcount(aShifted & b);
+    aShifted >>= 1;
+  }
+  return swaps % 2 === 0 ? 1 : -1;
+}
+
+export type Multivector4 = Float64Array; // length BLADE_COUNT, indexed by blade bitmask
+
+export function mvZero(): Multivector4 {
+  return new Float64Array(BLADE_COUNT);
+}
+
+/** Full geometric product of two multivectors: a * b. */
+export function geometricProductMV(a: Multivector4, b: Multivector4): Multivector4 {
+  const out = mvZero();
+  for (let i = 0; i < BLADE_COUNT; i++) {
+    const ai = a[i];
+    if (!ai) continue;
+    for (let j = 0; j < BLADE_COUNT; j++) {
+      const bj = b[j];
+      if (!bj) continue;
+      const blade = i ^ j;
+      out[blade] += reorderingSign(i, j) * ai * bj;
+    }
+  }
+  return out;
+}
+
+/** Outer (wedge) product: nonzero only for blade pairs that share no basis vector. */
+export function wedgeProductMV(a: Multivector4, b: Multivector4): Multivector4 {
+  const out = mvZero();
+  for (let i = 0; i < BLADE_COUNT; i++) {
+    const ai = a[i];
+    if (!ai) continue;
+    for (let j = 0; j < BLADE_COUNT; j++) {
+      const bj = b[j];
+      if (!bj || (i & j) !== 0) continue;
+      const blade = i ^ j;
+      out[blade] += reorderingSign(i, j) * ai * bj;
+    }
+  }
+  return out;
+}
+
+// Basis-vector and basis-bivector blade indices.
+export const E1 = 1 << 0;
+export const E2 = 1 << 1;
+export const E3 = 1 << 2;
+export const E4 = 1 << 3;
+export const E12 = E1 | E2;
+export const E13 = E1 | E3;
+export const E14 = E1 | E4;
+export const E23 = E2 | E3;
+export const E24 = E2 | E4;
+export const E34 = E3 | E4;
+export const PSEUDOSCALAR4 = E1 | E2 | E3 | E4;

package/src/Combinatorics.ts

@@ -0,0 +1,183 @@
+/**
+ * Combinatorics — exact counting mathematics: factorials, binomial/multinomial
+ * coefficients, Catalan/Stirling/Bell numbers, integer partitions, and
+ * derangements. The natural counting-math sibling to {@link Permutation},
+ * {@link Cycle}, and {@link GroupTheory} — none of those previously had a way
+ * to just compute `nCr`.
+ *
+ * Everything here is `bigint`-based (matching {@link NumberTheory}'s
+ * convention) since factorial-scale values exceed `Number.MAX_SAFE_INTEGER`
+ * well before n reaches 20.
+ */
+
+import { combinations, combinationsWithReplacement, permutations, product } from "./CombinatoricsGenerators.ts";
+
+const big = (x: bigint | number): bigint => (typeof x === "bigint" ? x : BigInt(x));
+
+export class Combinatorics {
+  /** `n!` */
+  static factorial(n: bigint | number): bigint {
+    const num = big(n);
+    if (num < 0n) throw new RangeError("factorial is undefined for negative numbers");
+    let result = 1n;
+    for (let i = 2n; i <= num; i++) result *= i;
+    return result;
+  }
+
+  /** `nCk` — the number of ways to choose `k` items from `n` (order doesn't matter). */
+  static binomial(n: bigint | number, k: bigint | number): bigint {
+    const N = big(n);
+    const K = big(k);
+    if (K < 0n || K > N) return 0n;
+    const kk = K > N - K ? N - K : K; // symmetry: nCk = nC(n-k)
+    let result = 1n;
+    for (let i = 0n; i < kk; i++) result = (result * (N - i)) / (i + 1n);
+    return result;
+  }
+
+  /** `nPk` — the number of ordered arrangements of `k` items chosen from `n`. */
+  static permutationsCount(n: bigint | number, k: bigint | number): bigint {
+    const N = big(n);
+    const K = big(k);
+    if (K < 0n || K > N) return 0n;
+    let result = 1n;
+    for (let i = 0n; i < K; i++) result *= N - i;
+    return result;
+  }
+
+  /** `n! / (k1! · k2! · … · km!)`, the number of ways to partition `n` labeled items into groups of the given sizes. */
+  static multinomial(n: bigint | number, groupSizes: Array<bigint | number>): bigint {
+    const N = big(n);
+    const sizes = groupSizes.map(big);
+    const sum = sizes.reduce((s, k) => s + k, 0n);
+    if (sum !== N) throw new RangeError("multinomial: group sizes must sum to n");
+    let result = Combinatorics.factorial(N);
+    for (const k of sizes) result /= Combinatorics.factorial(k);
+    return result;
+  }
+
+  /** The `n`th Catalan number: `C(2n, n) / (n + 1)` — counts balanced parenthesizations, binary trees, etc. */
+  static catalan(n: bigint | number): bigint {
+    const N = big(n);
+    if (N < 0n) throw new RangeError("catalan is undefined for negative numbers");
+    return Combinatorics.binomial(2n * N, N) / (N + 1n);
+  }
+
+  /** Stirling numbers of the second kind `S(n, k)` — ways to partition an `n`-set into `k` nonempty unlabeled subsets. */
+  static stirlingSecond(n: bigint | number, k: bigint | number): bigint {
+    const N = Number(big(n));
+    const K = Number(big(k));
+    if (N < 0 || K < 0) throw new RangeError("stirlingSecond is undefined for negative arguments");
+    if (K > N) return 0n;
+    // dp[j] holds S(i, j) for the current row i, built bottom-up.
+    const dp: bigint[] = new Array(N + 1).fill(0n);
+    dp[0] = 1n; // S(0, 0) = 1
+    for (let i = 1; i <= N; i++) {
+      for (let j = Math.min(i, K); j >= 1; j--) {
+        dp[j] = BigInt(j) * dp[j] + dp[j - 1];
+      }
+      dp[0] = 0n; // S(i, 0) = 0 for i > 0
+    }
+    return dp[K];
+  }
+
+  /** Unsigned Stirling numbers of the first kind `c(n, k)` — permutations of `n` elements with exactly `k` cycles. */
+  static stirlingFirstUnsigned(n: bigint | number, k: bigint | number): bigint {
+    const N = Number(big(n));
+    const K = Number(big(k));
+    if (N < 0 || K < 0) throw new RangeError("stirlingFirstUnsigned is undefined for negative arguments");
+    if (K > N) return 0n;
+    const dp: bigint[] = new Array(N + 1).fill(0n);
+    dp[0] = 1n; // c(0, 0) = 1
+    for (let i = 1; i <= N; i++) {
+      for (let j = Math.min(i, K); j >= 1; j--) {
+        dp[j] = BigInt(i - 1) * dp[j] + dp[j - 1];
+      }
+      dp[0] = 0n; // c(i, 0) = 0 for i > 0
+    }
+    return dp[K];
+  }
+
+  /**
+   * Full row of Stirling numbers of the second kind: `S(n, j)` for every `j` from `0` to `n`,
+   * built in a single `O(n²)` DP pass (same recurrence as {@link stirlingSecond}, but computed
+   * once for all columns instead of re-running the whole table per column).
+   */
+  private static stirlingSecondRow(n: number): bigint[] {
+    const dp: bigint[] = new Array(n + 1).fill(0n);
+    dp[0] = 1n; // S(0, 0) = 1
+    for (let i = 1; i <= n; i++) {
+      for (let j = i; j >= 1; j--) {
+        dp[j] = BigInt(j) * dp[j] + dp[j - 1];
+      }
+      dp[0] = 0n; // S(i, 0) = 0 for i > 0
+    }
+    return dp;
+  }
+
+  /** The `n`th Bell number — the total number of partitions of an `n`-set (`Σₖ S(n, k)`). */
+  static bell(n: bigint | number): bigint {
+    const N = Number(big(n));
+    if (N < 0) throw new RangeError("bell is undefined for negative numbers");
+    const row = Combinatorics.stirlingSecondRow(N);
+    let total = 0n;
+    for (let k = 0; k <= N; k++) total += row[k] as bigint;
+    return total;
+  }
+
+  /** The number of integer partitions of `n` (ways to write `n` as a sum of positive integers, order irrelevant). */
+  static partitionCount(n: bigint | number): bigint {
+    const N = Number(big(n));
+    if (N < 0) throw new RangeError("partitionCount is undefined for negative numbers");
+    const dp: bigint[] = new Array(N + 1).fill(0n);
+    dp[0] = 1n;
+    for (let part = 1; part <= N; part++) {
+      for (let total = part; total <= N; total++) dp[total] += dp[total - part];
+    }
+    return dp[N];
+  }
+
+  /** The number of derangements of `n` items (permutations with no fixed point), aka the subfactorial `!n`. */
+  static derangements(n: bigint | number): bigint {
+    const N = Number(big(n));
+    if (N < 0) throw new RangeError("derangements is undefined for negative numbers");
+    if (N === 0) return 1n;
+    if (N === 1) return 0n;
+    let prev2 = 1n; // !0
+    let prev1 = 0n; // !1
+    for (let i = 2; i <= N; i++) {
+      const cur = BigInt(i - 1) * (prev1 + prev2);
+      prev2 = prev1;
+      prev1 = cur;
+    }
+    return prev1;
+  }
+
+  // ---- enumeration ---------------------------------------------------------
+  // The counting functions above answer "how many?"; these yield the objects
+  // themselves. See CombinatoricsGenerators.ts for the algorithms.
+
+  /**
+   * Cartesian product of the given iterables, last varying fastest.
+   * Counting counterpart: multiply the pool sizes.
+   */
+  static product = product;
+
+  /**
+   * `r`-length permutations of `iterable` (default `r` = pool size).
+   * Counting counterpart: {@link Combinatorics.permutationsCount}.
+   */
+  static permutations = permutations;
+
+  /**
+   * `r`-length combinations of `iterable`, in input order.
+   * Counting counterpart: {@link Combinatorics.binomial}.
+   */
+  static combinations = combinations;
+
+  /**
+   * `r`-length combinations of `iterable` allowing repeats.
+   * Counting counterpart: `binomial(n + r - 1, r)`.
+   */
+  static combinationsWithReplacement = combinationsWithReplacement;
+}

package/src/CombinatoricsGenerators.ts

@@ -0,0 +1,144 @@
+/**
+ * Combinatorial generators: `product`, `permutations`, `combinations`,
+ * `combinationsWithReplacement` — ports of the iterative equivalent-code
+ * algorithms documented in CPython's itertools docs (chosen over a recursive
+ * approach to avoid recursion-depth limits on large inputs).
+ *
+ * These are the **enumerating** counterpart to {@link Combinatorics}'s
+ * **counting** functions: `Combinatorics.permutationsCount(n, r)` tells you how
+ * many there are, `Combinatorics.permutations(iterable, r)` yields them. They
+ * are surfaced as static methods on {@link Combinatorics} so both faces of each
+ * concept sit together.
+ *
+ * These are inherently "materialize fully, then compute" algorithms — CPython's
+ * own docs note that `product()` completely consumes its inputs before running,
+ * so a fully lazy formulation isn't available. Pools are therefore buffered in
+ * memory; enumerating a large product is bounded by that, not by laziness.
+ *
+ * Originally written for the library now published as `@johnhenry/iteration`;
+ * moved here because enumeration is mathematics rather than stream plumbing.
+ * The async duals stayed behind — they only added a "collect the source, then
+ * run this same sync generator" wrapper, and @johnhenry/math is deliberately
+ * synchronous throughout.
+ */
+
+function* productFromPools<T>(pools: T[][]): Generator<T[]> {
+  if (pools.some((pool) => pool.length === 0)) return;
+  const indices = pools.map(() => 0);
+  while (true) {
+    yield pools.map((pool, i) => pool[indices[i]]);
+    let i = indices.length - 1;
+    while (i >= 0) {
+      indices[i]++;
+      if (indices[i] < pools[i].length) break;
+      indices[i] = 0;
+      i--;
+    }
+    if (i < 0) return;
+  }
+}
+
+/**
+ * Cartesian product of the given iterables. Mirrors Python's
+ * itertools.product(*iterables) -- the last iterable varies fastest.
+ */
+export function* product<T>(...iterables: Array<Iterable<T>>): Generator<T[]> {
+  yield* productFromPools(iterables.map((it) => [...it]));
+}
+
+function* permutationsFromPool<T>(pool: T[], r?: number | null): Generator<T[]> {
+  const n = pool.length;
+  if (r === undefined || r === null) r = n;
+  if (r > n || r < 0) return;
+  const indices = Array.from({ length: n }, (_, i) => i);
+  const cycles = Array.from({ length: r }, (_, i) => n - i);
+  yield indices.slice(0, r).map((i) => pool[i]);
+  if (n === 0) return;
+  outer: while (true) {
+    for (let i = r - 1; i >= 0; i--) {
+      cycles[i] -= 1;
+      if (cycles[i] === 0) {
+        const tail = indices.slice(i + 1).concat(indices.slice(i, i + 1));
+        indices.splice(i, indices.length - i, ...tail);
+        cycles[i] = n - i;
+      } else {
+        const j = cycles[i];
+        const a = indices[i];
+        const b = indices[n - j];
+        indices[i] = b;
+        indices[n - j] = a;
+        yield indices.slice(0, r).map((idx) => pool[idx]);
+        continue outer;
+      }
+    }
+    return;
+  }
+}
+
+/**
+ * r-length permutations of `iterable` (default r = pool length). Mirrors
+ * Python's itertools.permutations(iterable, r).
+ */
+export function* permutations<T>(iterable: Iterable<T>, r?: number): Generator<T[]> {
+  yield* permutationsFromPool([...iterable], r);
+}
+
+function* combinationsFromPool<T>(pool: T[], r: number): Generator<T[]> {
+  const n = pool.length;
+  if (r > n || r < 0) return;
+  const indices = Array.from({ length: r }, (_, i) => i);
+  yield indices.map((i) => pool[i]);
+  while (true) {
+    let i = -1;
+    for (let k = r - 1; k >= 0; k--) {
+      if (indices[k] !== k + n - r) {
+        i = k;
+        break;
+      }
+    }
+    if (i === -1) return;
+    indices[i] += 1;
+    for (let j = i + 1; j < r; j++) {
+      indices[j] = indices[j - 1] + 1;
+    }
+    yield indices.map((idx) => pool[idx]);
+  }
+}
+
+/**
+ * r-length combinations of `iterable`, in sorted (input) order, without
+ * replacement. Mirrors Python's itertools.combinations(iterable, r).
+ */
+export function* combinations<T>(iterable: Iterable<T>, r: number): Generator<T[]> {
+  yield* combinationsFromPool([...iterable], r);
+}
+
+function* combinationsWithReplacementFromPool<T>(pool: T[], r: number): Generator<T[]> {
+  const n = pool.length;
+  if (n === 0 && r > 0) return;
+  const indices: number[] = new Array(r).fill(0);
+  yield indices.map((i) => pool[i]);
+  while (true) {
+    let i = -1;
+    for (let k = r - 1; k >= 0; k--) {
+      if (indices[k] !== n - 1) {
+        i = k;
+        break;
+      }
+    }
+    if (i === -1) return;
+    const value = indices[i] + 1;
+    for (let j = i; j < r; j++) {
+      indices[j] = value;
+    }
+    yield indices.map((idx) => pool[idx]);
+  }
+}
+
+/**
+ * r-length combinations of `iterable`, with replacement. Mirrors Python's
+ * itertools.combinations_with_replacement(iterable, r).
+ */
+export function* combinationsWithReplacement<T>(iterable: Iterable<T>, r: number): Generator<T[]> {
+  yield* combinationsWithReplacementFromPool([...iterable], r);
+}

package/src/ComplexMath.ts

@@ -0,0 +1,162 @@
+import { ComplexNumber } from "./ComplexNumber.ts";
+import { integrateN } from "./RealMath.ts";
+import { Vector } from "./Vector.ts";
+import { VectorUtils } from "./VectorUtils.ts";
+
+/**
+ * ComplexMath — the remaining complex-valued operations that don't belong on a
+ * single {@link ComplexNumber}: vector algebra over `Vector<ComplexNumber>`
+ * and probability distributions. Plain exported functions rather than a
+ * `static` method bag (same "namespace class" fix as {@link RealMath}).
+ *
+ * Everything per-value (arithmetic, exponentials/logs, trig, comparisons) is
+ * now a fluent {@link ComplexNumber} instance method. Matrix operations were
+ * dropped — `Structure.complexField()` already provides generic linear
+ * algebra. Order-dependent statistics (median/percentile/variance/etc.) were
+ * dropped with them: they had no test coverage here and don't generalize to
+ * complex numbers (there's no total order on the complex plane to found
+ * percentiles on) — see {@link Statistics} for the real-only equivalents.
+ *
+ * Ported from Mallory's ActionScript `ComplexMath`; see `ComplexNumber`'s doc
+ * comment for the bug fixes inherited from that port (directed-infinity
+ * division, zero-base `power`, etc.). `normalDistribution`'s AS3 bug (the
+ * reciprocal was taken of the whole PDF expression, flipping the exponential's
+ * sign) is fixed here too.
+ */
+
+type CNInput = ComplexNumber | number;
+type CVec = Vector<ComplexNumber>;
+type CUnary = (x: ComplexNumber) => ComplexNumber;
+
+const cn = (x: CNInput): ComplexNumber => (x instanceof ComplexNumber ? x : new ComplexNumber(x));
+
+// -- vectors ------------------------------------------------------------------
+
+export function addVector(alpha: CVec, beta: CVec): CVec {
+  return VectorUtils.combine(alpha, beta, (a, b) => a.add(b)) as CVec;
+}
+
+export function scaleVector(alpha: CVec, scalar: CNInput): CVec {
+  const s = cn(scalar);
+  return VectorUtils.transform(alpha, (x) => s.multiply(x));
+}
+
+export function negativeVector(alpha: CVec): CVec {
+  return scaleVector(alpha, -1);
+}
+
+export function subtractVector(alpha: CVec, beta: CVec): CVec {
+  return addVector(alpha, negativeVector(beta));
+}
+
+export function dotProduct(alpha: CVec, beta: CVec): ComplexNumber {
+  const collapsable = VectorUtils.combine(alpha, beta, (a, b) => a.multiply(b), ComplexNumber.Zero) as CVec;
+  return VectorUtils.collapse(collapsable, (a, b) => a.add(b)) as ComplexNumber;
+}
+
+/** 3D cross product (bug fix: index 2 for z, presence not truthiness — as in RealMath). */
+export function crossProduct(alpha: CVec, beta: CVec): CVec {
+  const a = [ComplexNumber.Zero, ComplexNumber.Zero, ComplexNumber.Zero];
+  const b = [ComplexNumber.Zero, ComplexNumber.Zero, ComplexNumber.Zero];
+  for (let idx = 0; idx < 3; idx++) {
+    if (idx < alpha.length && alpha[idx] != null) a[idx] = alpha[idx] as ComplexNumber;
+    if (idx < beta.length && beta[idx] != null) b[idx] = beta[idx] as ComplexNumber;
+  }
+  const i = a[1].multiply(b[2]).subtract(a[2].multiply(b[1]));
+  const j = a[2].multiply(b[0]).subtract(a[0].multiply(b[2]));
+  const k = a[0].multiply(b[1]).subtract(a[1].multiply(b[0]));
+  return Vector.fromArray([i, j, k]);
+}
+
+export function kroneckerProduct(A: CVec, B: CVec): CVec {
+  let kronecker = VectorUtils.constantVector(A.length, null as unknown) as Vector<unknown>;
+  kronecker = VectorUtils.fillByIndex(kronecker, (i) => scaleVector(B, A[i] as ComplexNumber));
+  return VectorUtils.flattenSDLevels(kronecker, 2) as CVec;
+}
+
+export function pNorm(alpha: CVec, norm: CNInput = 2): ComplexNumber {
+  const p = cn(norm);
+  if (p.value === 0) {
+    const magnitudes = VectorUtils.transform(alpha, (x) => new ComplexNumber(x.magnitude()));
+    return VectorUtils.collapse(magnitudes, (a, b) => (a.magCompare(b) >= 0 ? a : b)) as ComplexNumber;
+  }
+  const summable = VectorUtils.transform(alpha, (x) => new ComplexNumber(x.magnitude()).power(p.value));
+  const sum = VectorUtils.collapse(summable, (a, b) => a.add(b), ComplexNumber.Zero) as ComplexNumber;
+  return sum.power(1 / p.value);
+}
+
+export function distanceVector(alpha: CVec, beta: CVec, norm: CNInput = 2): ComplexNumber {
+  return pNorm(subtractVector(alpha, beta), norm);
+}
+
+export function magnitudeVector(alpha: CVec): ComplexNumber {
+  return pNorm(alpha, 2);
+}
+
+export function angleBetween(alpha: CVec, beta: CVec): ComplexNumber {
+  return dotProduct(alpha, beta)
+    .divide(magnitudeVector(alpha).multiply(magnitudeVector(beta)))
+    .arcCosine();
+}
+
+// -- probability ----------------------------------------------------------------
+
+export function zScore(x: CNInput, mean: CNInput = 0, sDev: CNInput = 1): ComplexNumber {
+  return cn(x).subtract(mean).divide(sDev);
+}
+
+export function invertZScore(z: CNInput, mean: CNInput = 0, sDev: CNInput = 1): ComplexNumber {
+  return cn(z).multiply(sDev).add(mean);
+}
+
+/** Normal PDF closure over complex arguments. */
+export function normalDistribution(mean: CNInput, sDev: CNInput): CUnary {
+  return (x: ComplexNumber) =>
+    cn(sDev)
+      .multiply(Math.sqrt(2 * Math.PI))
+      .reciprocal()
+      .multiply(ComplexNumber.E.power(zScore(x, mean, sDev).square().multiply(-0.5)));
+}
+
+export function standardNormalDistribution(x: CNInput): ComplexNumber {
+  return normalDistribution(0, 1)(cn(x));
+}
+
+/**
+ * Numeric integral of a complex-valued function over a real interval, via the
+ * real {@link integrateN} applied component-wise (bug fix: same midpoint-rule
+ * fix as `RealMath.integrateN`).
+ */
+function integrateComplexN(
+  unaryOperation: CUnary,
+  lowerLimit: number,
+  upperLimit: number,
+  interval = 0.0001,
+): ComplexNumber {
+  const re = integrateN((t) => unaryOperation(new ComplexNumber(t, 0)).value, lowerLimit, upperLimit, interval);
+  const im = integrateN((t) => unaryOperation(new ComplexNumber(t, 0)).iValue, lowerLimit, upperLimit, interval);
+  return new ComplexNumber(re, im);
+}
+
+export function normalProbability(
+  x: CNInput,
+  mean: CNInput,
+  sDev: CNInput,
+  negativeInfinityApproximation = -5,
+  integrationInterval = 0.0001,
+): ComplexNumber {
+  return integrateComplexN(
+    normalDistribution(mean, sDev),
+    negativeInfinityApproximation,
+    cn(x).value,
+    integrationInterval,
+  );
+}
+
+export function standardNormalProbability(
+  z: CNInput,
+  negativeInfinityApproximation = -5,
+  interval = 0.0001,
+): ComplexNumber {
+  return integrateComplexN(standardNormalDistribution, negativeInfinityApproximation, cn(z).value, interval);
+}