smithkit 0.0.0-stage → 0.1.0

package/dist/lib/SmithConstantCircle.js

@@ -0,0 +1,222 @@
+import { complexRatio } from './math/complexRatio.js';
+import { Complex } from './complex/Complex.js';
+export class SmithConstantCircle {
+    Z0;
+    constructor(Z0 = 50) {
+        this.Z0 = Z0;
+    }
+    rflCoeffToImpedance(c) {
+        return this.transform(c, 1 + c.re, c.im, 1 - c.re, -c.im, 2);
+    }
+    impedanceToRflCoeff(c) {
+        return this.transform(c, c.re - 1, c.im, c.re + 1, c.im, 2);
+    }
+    rflCoeffToAdmittance(c) {
+        return this.transform(c, 1 - c.re, -c.im, 1 + c.re, c.im, -2);
+    }
+    admittanceToRflCoeff(c) {
+        return this.transform(c, 1 - c.re, -c.im, 1 + c.re, c.im, -2);
+    }
+    transform(value, nr, ni, dr, di, determinant) {
+        const quotient = complexRatio(nr, ni, dr, di);
+        if (!quotient) {
+            return;
+        }
+        // The analytic imaginary numerator avoids cancellation of nearly equal products.
+        const scale = Math.max(Math.abs(dr), Math.abs(di));
+        const denominator = (dr / scale) ** 2 + (di / scale) ** 2;
+        const im = (determinant * (value.im / scale)) / denominator / scale;
+        return Number.isFinite(im) ? Complex.from(quotient.re, im) : undefined;
+    }
+    resistanceCircle(n) {
+        return { p: [n / (n + 1), 0], r: 1 / (n + 1) };
+    }
+    reactanceCircle(n) {
+        return { p: [1, 1 / n], r: Math.abs(1 / n) };
+    }
+    conductanceCircle(n) {
+        return { p: [-n / (n + 1), 0], r: 1 / (n + 1) };
+    }
+    susceptanceCircle(n) {
+        return { p: [-1, -1 / n], r: Math.abs(1 / n) };
+    }
+    constQCircle(q) {
+        // Center is (0, +1/Q) or (0, -1/Q).
+        return { p: [0, 1 / q], r: Math.sqrt(1 + 1 / (q * q)) };
+    }
+    rflCoeffToSwr(rc) {
+        const gamma = rc.abs();
+        return (1 + gamma) / (1 - gamma);
+    }
+    rflCoeffToDBS(rc) {
+        return this.swrTodBS(this.rflCoeffToSwr(rc));
+    }
+    swrToRflCoeffEOrI(swr) {
+        return (swr - 1) / (swr + 1);
+    }
+    swrTodBS(swr) {
+        return 20 * Math.log10(swr);
+    }
+    dBSToSwr(dBS) {
+        return 10 ** (dBS / 20.0);
+    }
+    dBSToAbsRflCoeff(dBS) {
+        const swr = this.dBSToSwr(dBS);
+        return this.swrToRflCoeffEOrI(swr);
+    }
+    rflCoeffToReturnLoss(rc) {
+        return -20.0 * Math.log10(this.rflCoeffEOrI(rc));
+    }
+    returnLossToRflCoeffEOrI(rl) {
+        return 10 ** (-rl / 20.0);
+    }
+    /** One-way attenuation scale, referenced to a fully reflecting termination. */
+    rflCoeffToAttenuation(rc) {
+        return this.rflCoeffToReturnLoss(rc) / 2;
+    }
+    attenuationToRflCoeff(attenuation) {
+        return 10 ** (-attenuation / 10);
+    }
+    rflCoeffToMismatchLoss(rc) {
+        // mismatch loss is reflection loss
+        const abs = this.rflCoeffEOrI(rc);
+        return (-10 / Math.LN10) * Math.log1p(-(abs ** 2));
+    }
+    mismatchLossToRflCoeffEOrI(ml) {
+        return Math.sqrt(1 - 10 ** (-ml / 10));
+    }
+    rflCoeffEOrI(rc) {
+        return Math.sqrt(this.rflCoeffP(rc));
+    }
+    rflCoeffP(rc) {
+        return rc.abs() ** 2;
+    }
+    rflCoeffPToEOrI(p) {
+        return Math.sqrt(p);
+    }
+    rflCoeffToQ(rc) {
+        const impedance = this.rflCoeffToImpedance(rc);
+        if (!impedance || (impedance.re === 0 && impedance.im === 0)) {
+            return;
+        }
+        return Math.abs(impedance.im / impedance.re);
+    }
+    rflCoeffToTransmCoeffP(rc) {
+        return 1 - this.rflCoeffEOrI(rc) ** 2;
+    }
+    transmCoeffPToRflCoeffEOrI(tcp) {
+        return Math.sqrt(1.0 - tcp);
+    }
+    rflCoeffToTransmCoeff(rc) {
+        // T = R + 1
+        return rc.add(1);
+    }
+    transmCoeffToRflCoeff(tc) {
+        return tc.sub(1);
+    }
+    rflCoeffToTransmCoeffEOrI(rc) {
+        // T = R + 1
+        const tc = this.rflCoeffToTransmCoeff(rc);
+        return tc.abs();
+    }
+    /** Current transmission magnitude using the voltage reflection coefficient. */
+    rflCoeffToCurrentTransmission(rc) {
+        return Math.hypot(1 - rc.re, rc.im);
+    }
+    // s. w. peak (const. p)
+    // MAX. LIMITS = |V|max/|V|max,0 = sqrt(VSWR)
+    rflCoeffToSwPeakConstP(rc) {
+        return Math.sqrt(this.rflCoeffToSwr(rc));
+    }
+    swPeakConstPToRflCoeffEOrI(swPeak) {
+        return this.swrToRflCoeffEOrI(swPeak ** 2);
+    }
+    // SW. LOSS COEF. = (Pincident + Preflect) / (Pincident - Preflect)
+    // SW. LOSS COEF. = (1+|S|^2) / (1-|S|^2)
+    rflCoeffToSwLossCoeff(rc) {
+        const abs = this.rflCoeffEOrI(rc);
+        return (1 + abs ** 2) / (1 - abs ** 2);
+    }
+    swLossCoeffToRflCoeffEOrI(swl) {
+        return Math.sqrt((swl - 1) / (swl + 1));
+    }
+    // public transmCoeffToInsertionLoss(tc: Complex): number {
+    //   return -20 * Math.log10()
+    // }
+    circleCircleIntersection(c1, c2) {
+        const dl = Math.sqrt(Math.pow(c2.p[0] - c1.p[0], 2) + Math.pow(c2.p[1] - c1.p[1], 2));
+        const cosA = (dl * dl + c1.r * c1.r - c2.r * c2.r) / (2 * dl * c1.r);
+        const sinA = Math.sqrt(1 - Math.pow(cosA, 2));
+        const vpx = ((c2.p[0] - c1.p[0]) * c1.r) / dl;
+        const vpy = ((c2.p[1] - c1.p[1]) * c1.r) / dl;
+        return [
+            [vpx * cosA - vpy * sinA + c1.p[0], vpx * sinA + vpy * cosA + c1.p[1]],
+            [vpx * cosA + vpy * sinA + c1.p[0], vpy * cosA - vpx * sinA + c1.p[1]],
+        ];
+    }
+    isPointWithinCircle(p, c) {
+        return Math.pow(p[0] - c.p[0], 2) + Math.pow(p[1] - c.p[1], 2) <= Math.pow(c.r, 2);
+    }
+    normalize(c) {
+        return c.div(this.Z0);
+    }
+    denormalize(c) {
+        return c.mul(this.Z0);
+    }
+    waveLengthFromFrequency(frequency) {
+        return 299792458 / frequency;
+    }
+    frequencyFromWaveLength(waveLength) {
+        return 299792458 / waveLength;
+    }
+    magnitude(c) {
+        return c.abs();
+    }
+    dB(value) {
+        return 20 * Math.log10(value);
+    }
+    reactanceToCapacitance(x, f) {
+        if (x >= 0) {
+            return null;
+        }
+        return -1 / (2 * Math.PI * f * x);
+    }
+    capacitanceToReactance(C, f) {
+        return Complex.from(0, -1 / (2 * Math.PI * f * C));
+    }
+    reactanceToInductance(x, f) {
+        if (x <= 0) {
+            return null;
+        }
+        return x / (2 * Math.PI * f);
+    }
+    inductanceToReactance(L, f) {
+        return Complex.from(0, 2 * Math.PI * f * L);
+    }
+    addImpedance(rc, imp) {
+        let Z = this.rflCoeffToImpedance(rc);
+        if (Z === undefined) {
+            return undefined;
+        }
+        Z = Z.add(imp.div(this.Z0));
+        return this.impedanceToRflCoeff(Z);
+    }
+    addAdmittance(rc, adm) {
+        let Y = this.rflCoeffToAdmittance(rc);
+        if (Y === undefined) {
+            return undefined;
+        }
+        Y = Y.add(adm.mul(this.Z0));
+        return this.admittanceToRflCoeff(Y);
+    }
+    tangentToCircleAngle(c, p) {
+        // tangent to a circle, angle = atag(a)
+        return this.rad2deg(Math.atan((c.p[0] - p[0]) / (p[1] - c.p[1])));
+    }
+    rad2deg(rad) {
+        return (rad * 180.0) / Math.PI;
+    }
+    deg2rad(deg) {
+        return (deg * Math.PI) / 180.0;
+    }
+}

package/dist/lib/arcs/Tick.d.ts

@@ -0,0 +1,33 @@
+export interface TickDef {
+    point: {
+        r: number;
+        i: number;
+    };
+    transform?: {
+        dx?: number;
+        dy?: number;
+        rotate?: number;
+    };
+    dp?: number;
+    textAnchor?: string;
+    dominantBaseline?: string;
+}
+export interface TickDefRequired {
+    point: {
+        r: number;
+        i: number;
+    };
+    transform: {
+        dx: number;
+        dy: number;
+        rotate: number;
+    };
+    dp: number;
+    textAnchor: string;
+    dominantBaseline: string;
+}
+export declare class Tick {
+    private def;
+    constructor(def: TickDef);
+    get definition(): TickDefRequired;
+}

package/dist/lib/arcs/Tick.js

@@ -0,0 +1,40 @@
+export class Tick {
+    def;
+    constructor(def) {
+        if (def.transform === undefined) {
+            def.transform = {};
+        }
+        if (def.transform.dx === undefined) {
+            def.transform.dx = 0;
+        }
+        if (def.transform.dy === undefined) {
+            def.transform.dy = 0;
+        }
+        if (def.transform.rotate === undefined) {
+            def.transform.rotate = 0;
+        }
+        if (def.dp === undefined) {
+            def.dp = 0;
+        }
+        if (def.textAnchor === undefined) {
+            def.textAnchor = 'start';
+        }
+        if (def.dominantBaseline === undefined) {
+            def.dominantBaseline = 'baseline';
+        }
+        this.def = {
+            point: { r: def.point.r, i: def.point.i },
+            transform: {
+                dx: def.transform.dx,
+                dy: def.transform.dy,
+                rotate: def.transform.rotate,
+            },
+            dp: def.dp,
+            textAnchor: def.textAnchor,
+            dominantBaseline: def.dominantBaseline,
+        };
+    }
+    get definition() {
+        return this.def;
+    }
+}

package/dist/lib/complex/Complex.d.ts

@@ -0,0 +1,130 @@
+export declare class Complex {
+    private readonly realPart;
+    private readonly imaginaryPart;
+    private tolerance;
+    private constructor();
+    static from(re: number, im?: number): Complex;
+    static from(rect: {
+        re: number;
+        im: number;
+    }): Complex;
+    static from(polar: {
+        r: number;
+        phi: number;
+    }): Complex;
+    static from(arr: readonly [number, number]): Complex;
+    private static fromPolar;
+    static one(): Complex;
+    static zero(): Complex;
+    static get i(): Complex;
+    get re(): number;
+    get im(): number;
+    get epsilon(): number;
+    set epsilon(e: number);
+    abs(): number;
+    arg(): number;
+    sign(): Complex;
+    conj(): Complex;
+    neg(): Complex;
+    inv(): Complex;
+    add(v: number | Complex): Complex;
+    sub(v: number | Complex): Complex;
+    mul(v: number | Complex): Complex;
+    div(v: number | Complex): Complex;
+    exp(): Complex;
+    log(): Complex;
+    log2(): Complex;
+    log10(): Complex;
+    pow(exponent: number): Complex;
+    sqrt(): Complex;
+    sin(): Complex;
+    asin(): Complex;
+    sinh(): Complex;
+    asinh(): Complex;
+    cos(): Complex;
+    acos(): Complex;
+    cosh(): Complex;
+    acosh(): Complex;
+    tan(): Complex;
+    atan(): Complex;
+    tanh(): Complex;
+    atanh(): Complex;
+    cot(): Complex;
+    acot(): Complex;
+    coth(): Complex;
+    acoth(): Complex;
+    sec(): Complex;
+    asec(): Complex;
+    sech(): Complex;
+    asech(): Complex;
+    csc(): Complex;
+    acsc(): Complex;
+    csch(): Complex;
+    acsch(): Complex;
+    equals(z: Complex): boolean;
+    toPolar(): [number, number];
+    toVector(): [number, number];
+    toString(dp?: number): string;
+    static abs(z: Complex): number;
+    static arg(z: Complex): number;
+    static sign(z: Complex): Complex;
+    static conj(z: Complex): Complex;
+    static neg(z: Complex): Complex;
+    static inv(z: Complex): Complex;
+    static add(z: Complex, v: number | Complex): Complex;
+    static sub(z: Complex, v: number | Complex): Complex;
+    static mul(z: Complex, v: number | Complex): Complex;
+    static div(z: Complex, v: number | Complex): Complex;
+    static exp(z: Complex): Complex;
+    static log(z: Complex): Complex;
+    static log2(z: Complex): Complex;
+    static log10(z: Complex): Complex;
+    static pow(z: Complex, exponent: number): Complex;
+    static sqrt(z: Complex): Complex;
+    static sin(z: Complex): Complex;
+    static asin(z: Complex): Complex;
+    static sinh(z: Complex): Complex;
+    static asinh(z: Complex): Complex;
+    static cos(z: Complex): Complex;
+    static acos(z: Complex): Complex;
+    static cosh(z: Complex): Complex;
+    static acosh(z: Complex): Complex;
+    static tan(z: Complex): Complex;
+    static atan(z: Complex): Complex;
+    static tanh(z: Complex): Complex;
+    static atanh(z: Complex): Complex;
+    static cot(z: Complex): Complex;
+    static acot(z: Complex): Complex;
+    static coth(z: Complex): Complex;
+    static acoth(z: Complex): Complex;
+    static sec(z: Complex): Complex;
+    static asec(z: Complex): Complex;
+    static sech(z: Complex): Complex;
+    static asech(z: Complex): Complex;
+    static csc(z: Complex): Complex;
+    static acsc(z: Complex): Complex;
+    static csch(z: Complex): Complex;
+    static acsch(z: Complex): Complex;
+    private static isFinite;
+    private static nan;
+    private static copySign;
+    private static logHypot;
+    /** Sum two products without premature overflow/underflow. Result is mantissa × 2^exponent. */
+    private static productSum;
+    private static scalePowerOfTwo;
+    /** Cartesian reciprocal, preserving signed zeros on branch cuts. */
+    private static reciprocal;
+    private static hyperbolicProduct;
+    private static hyperbolicReciprocal;
+    /**
+     * Elliptic coordinates for principal inverse functions (x,y >= 0).
+     * With a = (|z+1| + |z-1|)/2, return acosh(a) and sqrt(a²-x²).
+     * Rationalized hypot differences retain tiny components near the branch cuts.
+     * Principal branches: https://dlmf.nist.gov/4.37
+     */
+    private static inverseHyperbolicParts;
+    static equals(z1: Complex, z2: Complex, epsilon?: number): boolean;
+    static toPolar(z: Complex): [number, number];
+    static toVector(z: Complex): [number, number];
+    static toString(z: Complex, dp?: number): string;
+}