dsp-collection 0.2.5 → 0.2.6

package/math/MutableComplex.js

@@ -1,65 +1,64 @@
-import Complex from "./Complex.js";
-export default class MutableComplex extends Complex {
-    constructor(re = 0, im = 0) {
-        super(re, im);
-    }
-    static fromComplex(x) {
-        return new MutableComplex(x.re, x.im);
-    }
-    static expj(arg) {
-        return new MutableComplex(Math.cos(arg), Math.sin(arg));
-    }
-    static fromPolar(abs, arg) {
-        return new MutableComplex(abs * Math.cos(arg), abs * Math.sin(arg));
-    }
-    set(x) {
-        this.re = x.re;
-        this.im = x.im;
-    }
-    setReIm(re, im = 0) {
-        this.re = re;
-        this.im = im;
-    }
-    setExpj(arg) {
-        this.re = Math.cos(arg);
-        this.im = Math.sin(arg);
-    }
-    addRealTo(x) {
-        this.re += x;
-    }
-    addTo(x) {
-        this.re += x.re;
-        this.im += x.im;
-    }
-    subRealFrom(x) {
-        this.re -= x;
-    }
-    subFrom(x) {
-        this.re -= x.re;
-        this.im -= x.im;
-    }
-    mulByReal(x) {
-        this.re *= x;
-        this.im *= x;
-    }
-    mulBy(x) {
-        this.setMul(this.re, this.im, x.re, x.im);
-    }
-    divByReal(x) {
-        this.re /= x;
-        this.im /= x;
-    }
-    divBy(x) {
-        this.setDiv(this.re, this.im, x.re, x.im);
-    }
-    setMul(re1, im1, re2, im2) {
-        this.re = re1 * re2 - im1 * im2;
-        this.im = re1 * im2 + im1 * re2;
-    }
-    setDiv(re1, im1, re2, im2) {
-        const m = re1 * re1 + im1 * im1;
-        this.re = (re1 * re2 + im1 * im2) / m;
-        this.im = (im1 * re2 - re1 * im2) / m;
-    }
-}
-//# sourceMappingURL=MutableComplex.js.map
+import Complex from "./Complex.js";
+export default class MutableComplex extends Complex {
+    constructor(re = 0, im = 0) {
+        super(re, im);
+    }
+    static fromComplex(x) {
+        return new MutableComplex(x.re, x.im);
+    }
+    static expj(arg) {
+        return new MutableComplex(Math.cos(arg), Math.sin(arg));
+    }
+    static fromPolar(abs, arg) {
+        return new MutableComplex(abs * Math.cos(arg), abs * Math.sin(arg));
+    }
+    set(x) {
+        this.re = x.re;
+        this.im = x.im;
+    }
+    setReIm(re, im = 0) {
+        this.re = re;
+        this.im = im;
+    }
+    setExpj(arg) {
+        this.re = Math.cos(arg);
+        this.im = Math.sin(arg);
+    }
+    addRealTo(x) {
+        this.re += x;
+    }
+    addTo(x) {
+        this.re += x.re;
+        this.im += x.im;
+    }
+    subRealFrom(x) {
+        this.re -= x;
+    }
+    subFrom(x) {
+        this.re -= x.re;
+        this.im -= x.im;
+    }
+    mulByReal(x) {
+        this.re *= x;
+        this.im *= x;
+    }
+    mulBy(x) {
+        this.setMul(this.re, this.im, x.re, x.im);
+    }
+    divByReal(x) {
+        this.re /= x;
+        this.im /= x;
+    }
+    divBy(x) {
+        this.setDiv(this.re, this.im, x.re, x.im);
+    }
+    setMul(re1, im1, re2, im2) {
+        this.re = re1 * re2 - im1 * im2;
+        this.im = re1 * im2 + im1 * re2;
+    }
+    setDiv(re1, im1, re2, im2) {
+        const m = re1 * re1 + im1 * im1;
+        this.re = (re1 * re2 + im1 * im2) / m;
+        this.im = (im1 * re2 - re1 * im2) / m;
+    }
+}

package/math/NumApprox.d.ts

@@ -1,3 +1,3 @@
-export declare function argMax_scanArith(f: (x: number) => number, argLo: number, argHi: number, argIncr: number): number;
-export declare function argMax_scanGeom(f: (x: number) => number, argLo: number, argHi: number, argFactor: number): number;
-export declare function argMax_goldenSectionSearch(f: (x: number) => number, argLo: number, argHi: number, tolerance: number): number;
+export declare function argMax_scanArith(f: (x: number) => number, argLo: number, argHi: number, argIncr: number): number;
+export declare function argMax_scanGeom(f: (x: number) => number, argLo: number, argHi: number, argFactor: number): number;
+export declare function argMax_goldenSectionSearch(f: (x: number) => number, argLo: number, argHi: number, tolerance: number): number;

package/math/NumApprox.js

@@ -1,68 +1,67 @@
-export function argMax_scanArith(f, argLo, argHi, argIncr) {
-    let maxArg = NaN;
-    let maxVal = -Infinity;
-    let lastArg = NaN;
-    for (let x = argLo; x < argHi; x += argIncr) {
-        const v = f(x);
-        if (v > maxVal) {
-            maxArg = x;
-            maxVal = v;
-        }
-        lastArg = x;
-    }
-    if (lastArg != argHi && argHi > argLo && f(argHi) > maxVal) {
-        maxArg = argHi;
-    }
-    return maxArg;
-}
-export function argMax_scanGeom(f, argLo, argHi, argFactor) {
-    let maxArg = NaN;
-    let maxVal = -Infinity;
-    let lastArg = NaN;
-    for (let x = argLo; x < argHi; x *= argFactor) {
-        const v = f(x);
-        if (v > maxVal) {
-            maxArg = x;
-            maxVal = v;
-        }
-        lastArg = x;
-    }
-    if (lastArg != argHi && argHi > argLo && f(argHi) > maxVal) {
-        maxArg = argHi;
-    }
-    return maxArg;
-}
-export function argMax_goldenSectionSearch(f, argLo, argHi, tolerance) {
-    const invPhi = (Math.sqrt(5) - 1) / 2;
-    const invPhi2 = 1 - invPhi;
-    let lo = argLo;
-    let hi = argHi;
-    let width = hi - lo;
-    let x1 = lo + width * invPhi2;
-    let x2 = lo + width * invPhi;
-    let y1 = f(x1);
-    let y2 = f(x2);
-    if (width <= tolerance) {
-        return (lo + hi) / 2;
-    }
-    const n = Math.ceil(Math.log(tolerance / width) / Math.log(invPhi));
-    for (let i = 0; i < n; i++) {
-        width *= invPhi;
-        if (y1 >= y2) {
-            hi = x2;
-            x2 = x1;
-            y2 = y1;
-            x1 = lo + width * invPhi2;
-            y1 = f(x1);
-        }
-        else {
-            lo = x1;
-            x1 = x2;
-            y1 = y2;
-            x2 = lo + width * invPhi;
-            y2 = f(x2);
-        }
-    }
-    return (y1 >= y2) ? (lo + x2) / 2 : (x1 + hi) / 2;
-}
-//# sourceMappingURL=NumApprox.js.map
+export function argMax_scanArith(f, argLo, argHi, argIncr) {
+    let maxArg = NaN;
+    let maxVal = -Infinity;
+    let lastArg = NaN;
+    for (let x = argLo; x < argHi; x += argIncr) {
+        const v = f(x);
+        if (v > maxVal) {
+            maxArg = x;
+            maxVal = v;
+        }
+        lastArg = x;
+    }
+    if (lastArg != argHi && argHi > argLo && f(argHi) > maxVal) {
+        maxArg = argHi;
+    }
+    return maxArg;
+}
+export function argMax_scanGeom(f, argLo, argHi, argFactor) {
+    let maxArg = NaN;
+    let maxVal = -Infinity;
+    let lastArg = NaN;
+    for (let x = argLo; x < argHi; x *= argFactor) {
+        const v = f(x);
+        if (v > maxVal) {
+            maxArg = x;
+            maxVal = v;
+        }
+        lastArg = x;
+    }
+    if (lastArg != argHi && argHi > argLo && f(argHi) > maxVal) {
+        maxArg = argHi;
+    }
+    return maxArg;
+}
+export function argMax_goldenSectionSearch(f, argLo, argHi, tolerance) {
+    const invPhi = (Math.sqrt(5) - 1) / 2;
+    const invPhi2 = 1 - invPhi;
+    let lo = argLo;
+    let hi = argHi;
+    let width = hi - lo;
+    let x1 = lo + width * invPhi2;
+    let x2 = lo + width * invPhi;
+    let y1 = f(x1);
+    let y2 = f(x2);
+    if (width <= tolerance) {
+        return (lo + hi) / 2;
+    }
+    const n = Math.ceil(Math.log(tolerance / width) / Math.log(invPhi));
+    for (let i = 0; i < n; i++) {
+        width *= invPhi;
+        if (y1 >= y2) {
+            hi = x2;
+            x2 = x1;
+            y2 = y1;
+            x1 = lo + width * invPhi2;
+            y1 = f(x1);
+        }
+        else {
+            lo = x1;
+            x1 = x2;
+            y1 = y2;
+            x2 = lo + width * invPhi;
+            y2 = f(x2);
+        }
+    }
+    return (y1 >= y2) ? (lo + x2) / 2 : (x1 + hi) / 2;
+}

package/math/PolyReal.d.ts

@@ -1,13 +1,13 @@
-import Complex from "./Complex.js";
-export declare function evaluateReal(a: ArrayLike<number>, x: number): number;
-export declare function evaluateComplex(a: ArrayLike<number>, x: Complex): Complex;
-export declare function expand(zeros: ArrayLike<number>): Float64Array;
-export declare function compareEqual(a1: ArrayLike<number>, a2: ArrayLike<number>, eps?: number): boolean;
-export declare function add(a1: ArrayLike<number>, a2: ArrayLike<number>, eps?: number): Float64Array;
-export declare function multiply(a1: ArrayLike<number>, a2: ArrayLike<number>, eps?: number): Float64Array;
-export declare function divide(a1r: ArrayLike<number>, a2r: ArrayLike<number>, eps?: number): Float64Array[];
-export declare function gcd(a1: ArrayLike<number>, a2: ArrayLike<number>, eps?: number): Float64Array;
-export declare function evaluateFractionComplex(f: ArrayLike<number>[], x: Complex): Complex;
-export declare function addFractions(f1: ArrayLike<number>[], f2: ArrayLike<number>[], eps?: number): Float64Array[];
-export declare function multiplyFractions(f1: ArrayLike<number>[], f2: ArrayLike<number>[], eps?: number): Float64Array[];
-export declare function normalizeFraction(f: ArrayLike<number>[], eps?: number): Float64Array[];
+import Complex from "./Complex.ts";
+export declare function evaluateReal(a: ArrayLike<number>, x: number): number;
+export declare function evaluateComplex(a: ArrayLike<number>, x: Complex): Complex;
+export declare function expand(zeros: ArrayLike<number>): Float64Array;
+export declare function compareEqual(a1: ArrayLike<number>, a2: ArrayLike<number>, eps?: number): boolean;
+export declare function add(a1: ArrayLike<number>, a2: ArrayLike<number>, eps?: number): Float64Array;
+export declare function multiply(a1: ArrayLike<number>, a2: ArrayLike<number>, eps?: number): Float64Array;
+export declare function divide(a1r: ArrayLike<number>, a2r: ArrayLike<number>, eps?: number): Float64Array[];
+export declare function gcd(a1: ArrayLike<number>, a2: ArrayLike<number>, eps?: number): Float64Array;
+export declare function evaluateFractionComplex(f: ArrayLike<number>[], x: Complex): Complex;
+export declare function addFractions(f1: ArrayLike<number>[], f2: ArrayLike<number>[], eps?: number): Float64Array[];
+export declare function multiplyFractions(f1: ArrayLike<number>[], f2: ArrayLike<number>[], eps?: number): Float64Array[];
+export declare function normalizeFraction(f: ArrayLike<number>[], eps?: number): Float64Array[];