dsp-collection 0.2.4 → 0.2.6

package/math/ComplexArray.js

@@ -1,143 +1,170 @@
-import Complex from "./Complex";
-import MutableComplex from "./MutableComplex";
-const emptyFloat64Array = new Float64Array(0);
-export default class ComplexArray {
-    constructor(x = 0) {
-        if (typeof x == "number") {
-            this.constructByLength(x);
-        }
-        else if (x instanceof Float64Array) {
-            this.constructByFloat64Array(x);
-        }
-        else if (x instanceof Array && x[0] instanceof Complex) {
-            this.constructByArrayOfComplex(x);
-        }
-        else {
-            throw new Error("Invalid constructor argument.");
-        }
-    }
-    constructByLength(length) {
-        this.length = length;
-        if (length) {
-            this.re = new Float64Array(length);
-            this.im = new Float64Array(length);
-        }
-        else {
-            this.re = emptyFloat64Array;
-            this.im = emptyFloat64Array;
-        }
-    }
-    constructByFloat64Array(a) {
-        this.length = a.length;
-        this.re = a.slice();
-        this.im = new Float64Array(a.length);
-    }
-    constructByArrayOfComplex(a) {
-        this.length = a.length;
-        this.re = new Float64Array(a.length);
-        this.im = new Float64Array(a.length);
-        for (let i = 0; i < a.length; i++) {
-            this.re[i] = a[i].re;
-            this.im[i] = a[i].im;
-        }
-    }
-    slice(begin, end) {
-        const a2 = new ComplexArray();
-        a2.re = this.re.slice(begin, end);
-        a2.im = this.im.slice(begin, end);
-        a2.length = a2.re.length;
-        return a2;
-    }
-    subarray(begin, end) {
-        const a2 = new ComplexArray();
-        a2.re = this.re.subarray(begin, end);
-        a2.im = this.im.subarray(begin, end);
-        a2.length = end - begin;
-        return a2;
-    }
-    set(i, c) {
-        this.re[i] = c.re;
-        this.im[i] = c.im;
-    }
-    setReIm(i, re, im) {
-        this.re[i] = re;
-        this.im[i] = im;
-    }
-    static copy1(a1, i1, a2, i2) {
-        a2.re[i2] = a1.re[i1];
-        a2.im[i2] = a1.im[i1];
-    }
-    toString() {
-        let s = "[";
-        for (let i = 0; i < this.length; i++) {
-            if (i > 0) {
-                s += ", ";
-            }
-            s += "(" + this.re[i] + ", " + this.im[i] + ")";
-        }
-        s += "]";
-        return s;
-    }
-    get(i) {
-        return new MutableComplex(this.re[i], this.im[i]);
-    }
-    getAbs(i) {
-        return Math.hypot(this.re[i], this.im[i]);
-    }
-    getArg(i) {
-        return Math.atan2(this.im[i], this.re[i]);
-    }
-    addRealTo(i, x) {
-        this.re[i] += x;
-    }
-    addTo(i, x) {
-        this.re[i] += x.re;
-        this.im[i] += x.im;
-    }
-    subRealFrom(i, x) {
-        this.re[i] -= x;
-    }
-    subFrom(i, x) {
-        this.re[i] -= x.re;
-        this.im[i] -= x.im;
-    }
-    mulByReal(i, x) {
-        this.re[i] *= x;
-        this.im[i] *= x;
-    }
-    mulBy(i, x) {
-        this.setMul(i, this.re[i], this.im[i], x.re, x.im);
-    }
-    divByReal(i, x) {
-        this.re[i] /= x;
-        this.im[i] /= x;
-    }
-    divBy(i, x) {
-        this.setDiv(i, this.re[i], this.im[i], x.re, x.im);
-    }
-    mulByArray(a2) {
-        const n = this.length;
-        if (a2.length != n) {
-            throw new Error("Array sizes are not equal.");
-        }
-        for (let i = 0; i < n; i++) {
-            this.setMul(i, this.re[i], this.im[i], a2.re[i], a2.im[i]);
-        }
-    }
-    mulAllByReal(x) {
-        const n = this.length;
-        for (let i = 0; i < n; i++) {
-            this.mulByReal(i, x);
-        }
-    }
-    setMul(i, re1, im1, re2, im2) {
-        this.re[i] = re1 * re2 - im1 * im2;
-        this.im[i] = re1 * im2 + im1 * re2;
-    }
-    setDiv(i, re1, im1, re2, im2) {
-        const m = re1 * re1 + im1 * im1;
-        this.re[i] = (re1 * re2 + im1 * im2) / m;
-        this.im[i] = (im1 * re2 - re1 * im2) / m;
-    }
-}
-//# sourceMappingURL=ComplexArray.js.map
+import Complex from "./Complex.js";
+import MutableComplex from "./MutableComplex.js";
+import { assert } from "../utils/MiscUtils.js";
+const emptyFloat64Array = new Float64Array(0);
+export default class ComplexArray {
+    constructor(x = 0) {
+        if (typeof x == "number") {
+            this.constructByLength(x);
+        }
+        else if (Array.isArray(x) && x[0] instanceof Complex) {
+            this.constructByArrayOfComplex(x);
+        }
+        else if (x instanceof Object && x.length !== undefined) {
+            this.constructByArrayOfNumber(x);
+        }
+        else {
+            throw new Error("Invalid constructor argument.");
+        }
+    }
+    constructByLength(length) {
+        this.length = length;
+        if (length) {
+            this.re = new Float64Array(length);
+            this.im = new Float64Array(length);
+        }
+        else {
+            this.re = emptyFloat64Array;
+            this.im = emptyFloat64Array;
+        }
+    }
+    constructByArrayOfComplex(a) {
+        this.length = a.length;
+        this.re = new Float64Array(a.length);
+        this.im = new Float64Array(a.length);
+        for (let i = 0; i < a.length; i++) {
+            this.re[i] = a[i].re;
+            this.im[i] = a[i].im;
+        }
+    }
+    constructByArrayOfNumber(a) {
+        this.length = a.length;
+        this.re = new Float64Array(a);
+        this.im = new Float64Array(a.length);
+    }
+    static fromPolar(absArray, argArray) {
+        const n = absArray.length;
+        assert(n == argArray.length);
+        const a = new ComplexArray(n);
+        for (let i = 0; i < n; i++) {
+            a.setPolar(i, absArray[i], argArray[i]);
+        }
+        return a;
+    }
+    slice(begin, end) {
+        const a2 = new ComplexArray();
+        a2.re = this.re.slice(begin, end);
+        a2.im = this.im.slice(begin, end);
+        a2.length = a2.re.length;
+        return a2;
+    }
+    subarray(begin, end) {
+        const a2 = new ComplexArray();
+        a2.re = this.re.subarray(begin, end);
+        a2.im = this.im.subarray(begin, end);
+        a2.length = end - begin;
+        return a2;
+    }
+    set(i, c) {
+        this.re[i] = c.re;
+        this.im[i] = c.im;
+    }
+    setReIm(i, re, im) {
+        this.re[i] = re;
+        this.im[i] = im;
+    }
+    setPolar(i, abs, arg) {
+        this.re[i] = abs * Math.cos(arg);
+        this.im[i] = abs * Math.sin(arg);
+    }
+    static copy1(a1, i1, a2, i2) {
+        a2.re[i2] = a1.re[i1];
+        a2.im[i2] = a1.im[i1];
+    }
+    get(i) {
+        return new MutableComplex(this.re[i], this.im[i]);
+    }
+    getAbs(i) {
+        return Math.hypot(this.re[i], this.im[i]);
+    }
+    getArg(i) {
+        return Math.atan2(this.im[i], this.re[i]);
+    }
+    toString() {
+        let s = "[";
+        for (let i = 0; i < this.length; i++) {
+            if (i > 0) {
+                s += ", ";
+            }
+            s += "(" + this.re[i] + ", " + this.im[i] + ")";
+        }
+        s += "]";
+        return s;
+    }
+    getAbsArray() {
+        const n = this.length;
+        const a = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            a[i] = this.getAbs(i);
+        }
+        return a;
+    }
+    getArgArray() {
+        const n = this.length;
+        const a = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            a[i] = this.getArg(i);
+        }
+        return a;
+    }
+    addRealTo(i, x) {
+        this.re[i] += x;
+    }
+    addTo(i, x) {
+        this.re[i] += x.re;
+        this.im[i] += x.im;
+    }
+    subRealFrom(i, x) {
+        this.re[i] -= x;
+    }
+    subFrom(i, x) {
+        this.re[i] -= x.re;
+        this.im[i] -= x.im;
+    }
+    mulByReal(i, x) {
+        this.re[i] *= x;
+        this.im[i] *= x;
+    }
+    mulBy(i, x) {
+        this.setMul(i, this.re[i], this.im[i], x.re, x.im);
+    }
+    divByReal(i, x) {
+        this.re[i] /= x;
+        this.im[i] /= x;
+    }
+    divBy(i, x) {
+        this.setDiv(i, this.re[i], this.im[i], x.re, x.im);
+    }
+    mulByArray(a2) {
+        const n = this.length;
+        assert(a2.length == n);
+        for (let i = 0; i < n; i++) {
+            this.setMul(i, this.re[i], this.im[i], a2.re[i], a2.im[i]);
+        }
+    }
+    mulAllByReal(x) {
+        const n = this.length;
+        for (let i = 0; i < n; i++) {
+            this.mulByReal(i, x);
+        }
+    }
+    setMul(i, re1, im1, re2, im2) {
+        this.re[i] = re1 * re2 - im1 * im2;
+        this.im[i] = re1 * im2 + im1 * re2;
+    }
+    setDiv(i, re1, im1, re2, im2) {
+        const m = re1 * re1 + im1 * im1;
+        this.re[i] = (re1 * re2 + im1 * im2) / m;
+        this.im[i] = (im1 * re2 - re1 * im2) / m;
+    }
+}

package/math/MathUtils.d.ts

@@ -1,7 +1,9 @@
-export declare function fuzzyEquals(a: number, b: number, eps: number): boolean;
-export declare function isFuzzyInteger(i: number, eps: number): boolean;
-export declare function isPowerOf2(i: number): boolean;
-export declare function getNextPowerOf2(x: number): number;
-export declare function floorLog2(x: number): number;
-export declare function hyperbolicDecline(t: number, a: number, b: number): number;
-export declare function movingAverage(a: Float64Array, windowWidth: number): Float64Array;
+export declare function fuzzyEquals(a: number, b: number, eps: number): boolean;
+export declare function isFuzzyInteger(i: number, eps: number): boolean;
+export declare function isPowerOf2(i: number): boolean;
+export declare function getNextPowerOf2(x: number): number;
+export declare function floorLog2(x: number): number;
+export declare function hyperbolicDecline(t: number, a: number, b: number): number;
+export declare function simpleMovingAverage(a: ArrayLike<number>, windowWidth: number, shift?: boolean): Float64Array;
+export declare function triangularMovingAverage(a: ArrayLike<number>, windowWidth: number): Float64Array;
+export declare function triangularMovingAverageRef(a: ArrayLike<number>, windowWidth: number): Float64Array;

package/math/MathUtils.js

@@ -1,82 +1,116 @@
-export function fuzzyEquals(a, b, eps) {
-    if (!isFinite(a) || !isFinite(b)) {
-        return false;
-    }
-    if (a == b) {
-        return true;
-    }
-    const diff = Math.abs(a - b);
-    if (diff <= eps) {
-        return true;
-    }
-    const mag = Math.max(Math.abs(a), Math.abs(b));
-    return diff <= mag * eps;
-}
-export function isFuzzyInteger(i, eps) {
-    return Math.abs(i - Math.round(i)) <= eps;
-}
-export function isPowerOf2(i) {
-    if (!Number.isSafeInteger(i) || i < 1 || i > 0x40000000) {
-        return false;
-    }
-    return (i & (i - 1)) == 0;
-}
-export function getNextPowerOf2(x) {
-    if (!isFinite(x)) {
-        return NaN;
-    }
-    let n = 1;
-    while (n <= x) {
-        n *= 2;
-    }
-    return n;
-}
-export function floorLog2(x) {
-    if (x > 0x7FFFFFFF || x < 1) {
-        throw new Error("Argument is not a valid integer.");
-    }
-    return 31 - Math.clz32(x);
-}
-export function hyperbolicDecline(t, a, b) {
-    switch (b) {
-        case 1: {
-            return 1 / (1 + a * t);
-        }
-        case 0: {
-            return Math.exp(-a * t);
-        }
-        case -1: {
-            return Math.max(0, 1 - a * t);
-        }
-        default: {
-            return 1 / (1 + b * a * t) ** (1 / b);
-        }
-    }
-}
-export function movingAverage(a, windowWidth) {
-    if (windowWidth < 2 || !Number.isSafeInteger(windowWidth)) {
-        throw new Error("Specified window width is not a valid integer value.");
-    }
-    const len = a.length;
-    const a2 = new Float64Array(len);
-    const halfWindowWidth = Math.floor(windowWidth / 2);
-    const extendedLen = len + halfWindowWidth;
-    let movingSum = 0;
-    let n = 0;
-    for (let p = 0; p < extendedLen; p++) {
-        if (p >= windowWidth) {
-            movingSum -= a[p - windowWidth];
-            n--;
-        }
-        if (p < len) {
-            movingSum += a[p];
-            n++;
-        }
-        const p2 = p - halfWindowWidth;
-        if (p2 >= 0) {
-            a2[p2] = movingSum / n;
-        }
-    }
-    return a2;
-}
-//# sourceMappingURL=MathUtils.js.map
+export function fuzzyEquals(a, b, eps) {
+    if (!isFinite(a) || !isFinite(b)) {
+        return false;
+    }
+    if (a == b) {
+        return true;
+    }
+    const diff = Math.abs(a - b);
+    if (diff <= eps) {
+        return true;
+    }
+    const mag = Math.max(Math.abs(a), Math.abs(b));
+    return diff <= mag * eps;
+}
+export function isFuzzyInteger(i, eps) {
+    return Math.abs(i - Math.round(i)) <= eps;
+}
+export function isPowerOf2(i) {
+    if (!Number.isSafeInteger(i) || i < 1 || i > 0x40000000) {
+        return false;
+    }
+    return (i & (i - 1)) == 0;
+}
+export function getNextPowerOf2(x) {
+    if (!isFinite(x)) {
+        return NaN;
+    }
+    let n = 1;
+    while (n <= x) {
+        n *= 2;
+    }
+    return n;
+}
+export function floorLog2(x) {
+    if (x > 0x7FFFFFFF || x < 1) {
+        throw new Error("Argument is not a valid integer.");
+    }
+    return 31 - Math.clz32(x);
+}
+export function hyperbolicDecline(t, a, b) {
+    switch (b) {
+        case 1: {
+            return 1 / (1 + a * t);
+        }
+        case 0: {
+            return Math.exp(-a * t);
+        }
+        case -1: {
+            return Math.max(0, 1 - a * t);
+        }
+        default: {
+            return 1 / (1 + b * a * t) ** (1 / b);
+        }
+    }
+}
+export function simpleMovingAverage(a, windowWidth, shift = false) {
+    if (windowWidth < 2 || !Number.isSafeInteger(windowWidth)) {
+        throw new Error("Specified window width is not valid for SMA.");
+    }
+    const len = a.length;
+    const a2 = new Float64Array(len);
+    const halfWindowWidth = Math.floor(windowWidth / 2);
+    const posShift = (shift && windowWidth % 2 == 0) ? 1 : 0;
+    const extendedLen = len + halfWindowWidth;
+    let movingSum = 0;
+    let n = 0;
+    for (let p = 0; p < extendedLen; p++) {
+        if (p >= windowWidth) {
+            movingSum -= a[p - windowWidth];
+            n--;
+        }
+        if (p < len) {
+            movingSum += a[p];
+            n++;
+        }
+        const p2 = p - halfWindowWidth + posShift;
+        if (p2 >= 0 && p2 < len) {
+            a2[p2] = movingSum / n;
+        }
+    }
+    return a2;
+}
+export function triangularMovingAverage(a, windowWidth) {
+    if (windowWidth < 4 || !Number.isSafeInteger(windowWidth)) {
+        throw new Error("Specified window width is not valid for TMA.");
+    }
+    const w1 = Math.floor(windowWidth / 2);
+    const w2 = windowWidth - w1;
+    const a1 = simpleMovingAverage(a, w1);
+    const a2 = simpleMovingAverage(a1, w2, true);
+    return a2;
+}
+export function triangularMovingAverageRef(a, windowWidth) {
+    if (windowWidth < 4 || !Number.isSafeInteger(windowWidth)) {
+        throw new Error("Specified window width is not valid for TMA.");
+    }
+    const len = a.length;
+    const a2 = new Float64Array(len);
+    for (let p = 0; p < len; p++) {
+        a2[p] = computeTriangularAverageAt(a, p, windowWidth);
+    }
+    return a2;
+}
+function computeTriangularAverageAt(a, p, windowWidth) {
+    const len = a.length;
+    const p1 = Math.max(0, Math.ceil(p - windowWidth / 2 + 0.1));
+    const p2 = Math.min(len - 1, Math.floor(p + windowWidth / 2 - 0.1));
+    let sum = 0;
+    let weightSum = 0;
+    for (let i = p1; i <= p2; i++) {
+        const weight = 1 - Math.abs(i - p) / (windowWidth / 2);
+        sum += a[i] * weight;
+        weightSum += weight;
+    }
+    return sum / weightSum;
+}

package/math/MutableComplex.d.ts

@@ -1,22 +1,22 @@
-import Complex from "./Complex";
-export default class MutableComplex extends Complex {
-    re: number;
-    im: number;
-    constructor(re?: number, im?: number);
-    static fromComplex(x: Complex): MutableComplex;
-    static expj(arg: number): MutableComplex;
-    static fromPolar(abs: number, arg: number): MutableComplex;
-    set(x: Complex): void;
-    setReIm(re: number, im?: number): void;
-    setExpj(arg: number): void;
-    addRealTo(x: number): void;
-    addTo(x: Complex): void;
-    subRealFrom(x: number): void;
-    subFrom(x: Complex): void;
-    mulByReal(x: number): void;
-    mulBy(x: Complex): void;
-    divByReal(x: number): void;
-    divBy(x: Complex): void;
-    setMul(re1: number, im1: number, re2: number, im2: number): void;
-    setDiv(re1: number, im1: number, re2: number, im2: number): void;
-}
+import Complex from "./Complex.ts";
+export default class MutableComplex extends Complex {
+    re: number;
+    im: number;
+    constructor(re?: number, im?: number);
+    static fromComplex(x: Complex): MutableComplex;
+    static expj(arg: number): MutableComplex;
+    static fromPolar(abs: number, arg: number): MutableComplex;
+    set(x: Complex): void;
+    setReIm(re: number, im?: number): void;
+    setExpj(arg: number): void;
+    addRealTo(x: number): void;
+    addTo(x: Complex): void;
+    subRealFrom(x: number): void;
+    subFrom(x: Complex): void;
+    mulByReal(x: number): void;
+    mulBy(x: Complex): void;
+    divByReal(x: number): void;
+    divBy(x: Complex): void;
+    setMul(re1: number, im1: number, re2: number, im2: number): void;
+    setDiv(re1: number, im1: number, re2: number, im2: number): void;
+}