smithkit 0.0.0-stage → 0.1.0

package/dist/lib/complex/Complex.js

@@ -0,0 +1,636 @@
+export class Complex {
+    realPart;
+    imaginaryPart;
+    tolerance = Number.EPSILON;
+    constructor(re, im) {
+        this.realPart = re;
+        this.imaginaryPart = im;
+    }
+    static from(...args) {
+        if (args.length === 1) {
+            const arg = args[0];
+            if (typeof arg === 'number') {
+                return new Complex(arg, 0);
+            }
+            if (typeof arg === 'object' &&
+                arg !== null &&
+                're' in arg &&
+                'im' in arg &&
+                typeof arg.re === 'number' &&
+                typeof arg.im === 'number') {
+                return new Complex(arg.re, arg.im);
+            }
+            if (typeof arg === 'object' &&
+                arg !== null &&
+                'r' in arg &&
+                'phi' in arg &&
+                typeof arg.r === 'number' &&
+                typeof arg.phi === 'number') {
+                return Complex.fromPolar(arg.r, arg.phi);
+            }
+            if (Array.isArray(arg) && arg.length === 2) {
+                return new Complex(arg[0], arg[1]);
+            }
+        }
+        if (args.length === 2) {
+            const arg0 = args[0];
+            const arg1 = args[1];
+            if (typeof arg0 === 'number' && typeof arg1 === 'number') {
+                return new Complex(arg0, arg1);
+            }
+        }
+        throw new Error('Cannot create complex number, invalid arguments.');
+    }
+    static fromPolar(r, phi) {
+        return new Complex(r * Math.cos(phi), r * Math.sin(phi));
+    }
+    static one() {
+        return new Complex(1, 0);
+    }
+    static zero() {
+        return new Complex(0, 0);
+    }
+    static get i() {
+        return new Complex(0, 1);
+    }
+    get re() {
+        return this.realPart;
+    }
+    get im() {
+        return this.imaginaryPart;
+    }
+    get epsilon() {
+        return this.tolerance;
+    }
+    set epsilon(e) {
+        this.tolerance = e;
+    }
+    abs() {
+        return Complex.abs(this);
+    }
+    arg() {
+        return Complex.arg(this);
+    }
+    sign() {
+        return Complex.sign(this);
+    }
+    conj() {
+        return Complex.conj(this);
+    }
+    neg() {
+        return Complex.neg(this);
+    }
+    inv() {
+        return Complex.inv(this);
+    }
+    add(v) {
+        return Complex.add(this, v);
+    }
+    sub(v) {
+        return Complex.sub(this, v);
+    }
+    mul(v) {
+        return Complex.mul(this, v);
+    }
+    div(v) {
+        return Complex.div(this, v);
+    }
+    exp() {
+        return Complex.exp(this);
+    }
+    log() {
+        return Complex.log(this);
+    }
+    log2() {
+        return Complex.log2(this);
+    }
+    log10() {
+        return Complex.log10(this);
+    }
+    pow(exponent) {
+        return Complex.pow(this, exponent);
+    }
+    sqrt() {
+        return Complex.sqrt(this);
+    }
+    sin() {
+        return Complex.sin(this);
+    }
+    asin() {
+        return Complex.asin(this);
+    }
+    sinh() {
+        return Complex.sinh(this);
+    }
+    asinh() {
+        return Complex.asinh(this);
+    }
+    cos() {
+        return Complex.cos(this);
+    }
+    acos() {
+        return Complex.acos(this);
+    }
+    cosh() {
+        return Complex.cosh(this);
+    }
+    acosh() {
+        return Complex.acosh(this);
+    }
+    tan() {
+        return Complex.tan(this);
+    }
+    atan() {
+        return Complex.atan(this);
+    }
+    tanh() {
+        return Complex.tanh(this);
+    }
+    atanh() {
+        return Complex.atanh(this);
+    }
+    cot() {
+        return Complex.cot(this);
+    }
+    acot() {
+        return Complex.acot(this);
+    }
+    coth() {
+        return Complex.coth(this);
+    }
+    acoth() {
+        return Complex.acoth(this);
+    }
+    sec() {
+        return Complex.sec(this);
+    }
+    asec() {
+        return Complex.asec(this);
+    }
+    sech() {
+        return Complex.sech(this);
+    }
+    asech() {
+        return Complex.asech(this);
+    }
+    csc() {
+        return Complex.csc(this);
+    }
+    acsc() {
+        return Complex.acsc(this);
+    }
+    csch() {
+        return Complex.csch(this);
+    }
+    acsch() {
+        return Complex.acsch(this);
+    }
+    equals(z) {
+        return Complex.equals(this, z, this.epsilon);
+    }
+    toPolar() {
+        return Complex.toPolar(this);
+    }
+    toVector() {
+        return Complex.toVector(this);
+    }
+    toString(dp = 3) {
+        return Complex.toString(this, dp);
+    }
+    static abs(z) {
+        return Math.sqrt(z.re ** 2 + z.im ** 2);
+    }
+    static arg(z) {
+        return Math.atan2(z.im, z.re);
+    }
+    static sign(z) {
+        const abs = z.abs();
+        return Complex.from({
+            re: z.re / abs,
+            im: z.im / abs,
+        });
+    }
+    static conj(z) {
+        return Complex.from(z.re, -z.im);
+    }
+    static neg(z) {
+        return Complex.from(-z.re, -z.im);
+    }
+    static inv(z) {
+        return Complex.reciprocal(z);
+    }
+    static add(z, v) {
+        if (typeof v === 'number') {
+            return Complex.from(z.re + v, z.im);
+        }
+        else {
+            return Complex.from(z.re + v.re, z.im + v.im);
+        }
+    }
+    static sub(z, v) {
+        if (typeof v === 'number') {
+            return Complex.from(z.re - v, z.im);
+        }
+        else {
+            return Complex.from(z.re - v.re, z.im - v.im);
+        }
+    }
+    static mul(z, v) {
+        if (!Complex.isFinite(z) ||
+            (typeof v === 'number' ? !Number.isFinite(v) : !Complex.isFinite(v))) {
+            return Complex.nan();
+        }
+        if (typeof v === 'number') {
+            return Complex.from(z.re * v, z.im * v);
+        }
+        const real = Complex.productSum(z.re, v.re, -z.im, v.im);
+        const imaginary = Complex.productSum(z.re, v.im, z.im, v.re);
+        return Complex.from(Complex.scalePowerOfTwo(...real), Complex.scalePowerOfTwo(...imaginary));
+    }
+    static div(z, v) {
+        if (!Complex.isFinite(z) ||
+            (typeof v === 'number' ? !Number.isFinite(v) : !Complex.isFinite(v))) {
+            return Complex.nan();
+        }
+        if (typeof v === 'number') {
+            return v === 0 ? Complex.nan() : Complex.from(z.re / v, z.im / v);
+        }
+        if (v.re === 0 && v.im === 0) {
+            return Complex.nan();
+        }
+        // Keep products as mantissa/exponent pairs, including subnormal inputs.
+        // Neither squaring the denominator nor cancellation requires an infinite intermediate.
+        const [denominator, exponent] = Complex.productSum(v.re, v.re, v.im, v.im);
+        const quotient = (a, b, c, d) => {
+            const [numerator, power] = Complex.productSum(a, b, c, d);
+            return Complex.scalePowerOfTwo(numerator / denominator, power - exponent);
+        };
+        return Complex.from(quotient(z.re, v.re, z.im, v.im), quotient(z.im, v.re, -z.re, v.im));
+    }
+    static exp(z) {
+        // e^(a + bi) = e^a * e^bi = e^a * (cos(b) + i sin(b))
+        const eRe = Math.exp(z.re);
+        return Complex.from({
+            re: eRe * Math.cos(z.im),
+            im: eRe * Math.sin(z.im),
+        });
+    }
+    static log(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        return Complex.from(Complex.logHypot(z.re, z.im), z.arg());
+    }
+    static log2(z) {
+        const value = Complex.log(z);
+        return Complex.from(value.re * Math.LOG2E, value.im * Math.LOG2E);
+    }
+    static log10(z) {
+        const value = Complex.log(z);
+        return Complex.from(value.re * Math.LOG10E, value.im * Math.LOG10E);
+    }
+    static pow(z, exponent) {
+        if (!Complex.isFinite(z) || !Number.isFinite(exponent)) {
+            return Complex.nan();
+        }
+        if (exponent === 0) {
+            return Complex.one();
+        }
+        if (exponent === 1) {
+            return Complex.from(z.re, z.im);
+        }
+        if (exponent === -1) {
+            return Complex.inv(z);
+        }
+        if (exponent === 0.5) {
+            return Complex.sqrt(z);
+        }
+        if (exponent === 2) {
+            return Complex.mul(z, z);
+        }
+        if (z.re === 0 && z.im === 0) {
+            return exponent > 0 ? Complex.zero() : Complex.nan();
+        }
+        const logRadius = Complex.logHypot(z.re, z.im) * exponent;
+        const angle = z.arg() * exponent;
+        const component = (factor) => factor === 0
+            ? factor
+            : Complex.copySign(Math.exp(logRadius + Math.log(Math.abs(factor))), factor);
+        return Complex.from(component(Math.cos(angle)), component(Math.sin(angle)));
+    }
+    static sqrt(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        const scale = Math.max(Math.abs(z.re), Math.abs(z.im));
+        if (scale === 0) {
+            return Complex.from(0, z.im);
+        }
+        const x = z.re / scale;
+        const y = z.im / scale;
+        const root = Math.sqrt(scale) * Math.sqrt((Math.hypot(x, y) + Math.abs(x)) / 2);
+        return z.re >= 0
+            ? Complex.from(root, z.im / (2 * root))
+            : Complex.from(Math.abs(z.im) / (2 * root), Complex.copySign(root, z.im));
+    }
+    static sin(z) {
+        // sin(a+bi) = sin(a)cosh(b) + icos(a)sinh(b)
+        // https://proofwiki.org/wiki/Sine_of_Complex_Number
+        return Complex.from(Math.sin(z.re) * Math.cosh(z.im), Math.cos(z.re) * Math.sinh(z.im));
+    }
+    static asin(z) {
+        // asin(z) = -i * ln(zi + sqrt(1 - z^2))
+        // ref. https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Logarithmic_forms
+        const C = Complex;
+        const i = C.i;
+        return i.neg().mul(C.log(z.mul(i).add(C.sqrt(C.one().sub(z.pow(2))))));
+    }
+    static sinh(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        return Complex.from(Complex.hyperbolicProduct(z.re, Math.cos(z.im), true), Complex.hyperbolicProduct(z.re, Math.sin(z.im), false));
+    }
+    static asinh(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        const x = Math.abs(z.re);
+        const y = Math.abs(z.im);
+        if (Math.max(x, y) < 1e-8) {
+            return Complex.from(z.re, z.im);
+        }
+        if (y < 1 && x < 1e-150) {
+            return Complex.from(z.re / (Math.sqrt(1 - y) * Math.sqrt(1 + y)), Math.asin(z.im));
+        }
+        if (Math.max(x, y) > 1e150) {
+            return Complex.from(Complex.copySign(Complex.logHypot(x, y) + Math.LN2, z.re), Math.atan2(z.im, x));
+        }
+        const { real, transverse } = Complex.inverseHyperbolicParts(y, x);
+        return Complex.from(Complex.copySign(real, z.re), Complex.copySign(Math.atan2(y, transverse), z.im));
+    }
+    static cos(z) {
+        // cos(a+bi) = cos(a)cosh(b) + isin(a)sinh(b)
+        // https://proofwiki.org/wiki/Cosine_of_Complex_Number
+        return Complex.from(Math.cos(z.re) * Math.cosh(z.im), -Math.sin(z.re) * Math.sinh(z.im));
+    }
+    static acos(z) {
+        // acos(z) = -i * ln(z + sqrt(z^2 - 1))
+        //         = pi/2 + i * ln(zi + sqrt(1 - z^2))
+        //         = pi/2 - asin(z)
+        // ref. https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Logarithmic_forms
+        return Complex.from(Math.PI / 2).sub(z.asin());
+    }
+    static cosh(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        return Complex.from(Complex.hyperbolicProduct(z.re, Math.cos(z.im), false), Complex.hyperbolicProduct(z.re, Math.sin(z.im), true));
+    }
+    static acosh(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        if (Math.abs(z.re) < 1 && Math.abs(z.im) < 1e-150) {
+            return Complex.from(Math.abs(z.im) / (Math.sqrt(1 - z.re) * Math.sqrt(1 + z.re)), Complex.copySign(Math.acos(z.re), z.im));
+        }
+        if (Math.max(Math.abs(z.re), Math.abs(z.im)) > 1e150) {
+            return Complex.from(Complex.logHypot(z.re, z.im) + Math.LN2, Math.atan2(z.im, z.re));
+        }
+        const { real, transverse } = Complex.inverseHyperbolicParts(Math.abs(z.re), Math.abs(z.im));
+        return Complex.from(real, Complex.copySign(Math.atan2(transverse, z.re), z.im));
+    }
+    static tan(z) {
+        return z.sin().div(z.cos());
+    }
+    static atan(z) {
+        // atan(z) = i / 2 * ln((i + z) / (i - z))
+        //         = i / 2 * [ln(1 - iz) - ln(1 + iz)]
+        // ref. https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Logarithmic_forms
+        const C = Complex;
+        const i = C.i;
+        const z1 = C.log(C.one().sub(i.mul(z)));
+        const z2 = C.log(C.one().add(i.mul(z)));
+        return i.div(2).mul(z1.sub(z2));
+    }
+    static tanh(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        // Divide through by exp(2|x|); expm1 retains the real part near zero.
+        const q = Math.exp(-2 * Math.abs(z.re));
+        const difference = -Math.expm1(-2 * Math.abs(z.re));
+        const cos = Math.cos(z.im);
+        const sin = Math.sin(z.im);
+        const denominator = difference * difference + 4 * q * cos * cos;
+        return Complex.from(Complex.copySign((difference * (1 + q)) / denominator, z.re), (4 * q * sin * cos) / denominator);
+    }
+    static atanh(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        const x = Math.abs(z.re);
+        const y = Math.abs(z.im);
+        if (Math.max(x, y) > 1e150) {
+            return Complex.from(Complex.reciprocal(z).re, Complex.copySign(Math.PI / 2, z.im));
+        }
+        const distance = Math.hypot(1 - x, y);
+        const real = distance < 1e-150
+            ? (Complex.logHypot(1 + x, y) - Complex.logHypot(1 - x, y)) / 2
+            : Math.log1p((4 * (x / distance)) / distance) / 4;
+        const imag = Math.atan2(2 * z.im, (1 - x) * (1 + x) - y * y) / 2;
+        return Complex.from(Complex.copySign(real, z.re), imag);
+    }
+    static cot(z) {
+        return z.cos().div(z.sin());
+    }
+    static acot(z) {
+        // atan(z) = i / 2 * ln((i - z) / (i + z))
+        //         = i / 2 * [ln(1 - i/z) - ln(1 + i/z)]
+        // ref. https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Logarithmic_forms
+        const C = Complex;
+        const i = C.i;
+        const z1 = C.log(C.one().sub(i.div(z)));
+        const z2 = C.log(C.one().add(i.div(z)));
+        return i.div(2).mul(z1.sub(z2));
+    }
+    static coth(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        return Complex.reciprocal(Complex.tanh(z));
+    }
+    static acoth(z) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        if (Math.max(Math.abs(z.re), Math.abs(z.im)) < 1e-150) {
+            return Complex.from(z.re, Complex.copySign(Math.PI / 2, -z.im));
+        }
+        return Complex.atanh(Complex.reciprocal(z));
+    }
+    static sec(z) {
+        return Complex.sech(Complex.from(-z.im, z.re));
+    }
+    static asec(z) {
+        // asec(z) = -i * ln(sqrt(1 / z^2 - 1) + 1 / z))
+        // ref. https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Logarithmic_forms
+        const C = Complex;
+        const i = C.i;
+        return i.neg().mul(C.log(C.sqrt(C.one().div(z.pow(2)).sub(1)).add(z.inv())));
+    }
+    static sech(z) {
+        return Complex.hyperbolicReciprocal(z, true);
+    }
+    static asech(z) {
+        if (!Complex.isFinite(z) || (z.re === 0 && z.im === 0)) {
+            return Complex.nan();
+        }
+        if (Math.max(Math.abs(z.re), Math.abs(z.im)) < 1e-150) {
+            return Complex.from(Math.LN2 - Complex.logHypot(z.re, z.im), -Math.atan2(z.im, z.re));
+        }
+        return Complex.acosh(Complex.reciprocal(z));
+    }
+    static csc(z) {
+        const value = Complex.csch(Complex.from(-z.im, z.re));
+        return Complex.from(-value.im, value.re);
+    }
+    static acsc(z) {
+        // acsc(z) = -i * ln(sqrt(1 - 1 / z^2) + i / z))
+        // ref. https://en.wikipedia.org/wiki/Inverse_trigonometric_functions#Logarithmic_forms
+        const C = Complex;
+        const i = C.i;
+        return i.neg().mul(C.log(C.sqrt(C.one().sub(C.one().div(z.pow(2)))).add(i.div(z))));
+    }
+    static csch(z) {
+        return Complex.hyperbolicReciprocal(z, false);
+    }
+    static acsch(z) {
+        if (!Complex.isFinite(z) || (z.re === 0 && z.im === 0)) {
+            return Complex.nan();
+        }
+        if (Math.max(Math.abs(z.re), Math.abs(z.im)) < 1e-150) {
+            return Complex.from(Complex.copySign(Math.LN2 - Complex.logHypot(z.re, z.im), z.re), Math.atan2(-z.im, Math.abs(z.re)));
+        }
+        return Complex.asinh(Complex.reciprocal(z));
+    }
+    static isFinite(z) {
+        return Number.isFinite(z.re) && Number.isFinite(z.im);
+    }
+    static nan() {
+        return Complex.from(NaN, NaN);
+    }
+    static copySign(magnitude, sign) {
+        return sign < 0 || Object.is(sign, -0) ? -Math.abs(magnitude) : Math.abs(magnitude);
+    }
+    static logHypot(x, y) {
+        const scale = Math.max(Math.abs(x), Math.abs(y));
+        return scale === 0 ? -Infinity : Math.log(scale) + Math.log(Math.hypot(x / scale, y / scale));
+    }
+    /** Sum two products without premature overflow/underflow. Result is mantissa × 2^exponent. */
+    static productSum(a, b, c, d) {
+        const product = (x, y) => {
+            if (x === 0 || y === 0) {
+                return [x * y, 0];
+            }
+            const ex = Math.min(1023, Math.floor(Math.log2(Math.abs(x))));
+            const ey = Math.min(1023, Math.floor(Math.log2(Math.abs(y))));
+            return [(x / 2 ** ex) * (y / 2 ** ey), ex + ey];
+        };
+        const [first, ef] = product(a, b);
+        const [second, es] = product(c, d);
+        if (first === 0) {
+            return second === 0 ? [first + second, 0] : [second, es];
+        }
+        if (second === 0) {
+            return [first, ef];
+        }
+        const exponent = Math.max(ef, es);
+        return [first * 2 ** (ef - exponent) + second * 2 ** (es - exponent), exponent];
+    }
+    static scalePowerOfTwo(value, exponent) {
+        if (value === 0) {
+            return value;
+        }
+        // Normalize after cancellation before splitting the final exponent.
+        const shift = Math.min(1023, Math.floor(Math.log2(Math.abs(value))));
+        value /= 2 ** shift;
+        exponent += shift;
+        if (exponent > 1023) {
+            return value * 2 ** (exponent - 1023) * 2 ** 1023;
+        }
+        if (exponent < -1022) {
+            return value * 2 ** (exponent + 1022) * 2 ** -1022;
+        }
+        return value * 2 ** exponent;
+    }
+    /** Cartesian reciprocal, preserving signed zeros on branch cuts. */
+    static reciprocal(z) {
+        const value = Complex.div(Complex.one(), z);
+        if (Number.isNaN(value.re)) {
+            return value;
+        }
+        return Complex.from(z.re === 0 ? Complex.copySign(0, z.re) : value.re, z.im === 0 ? Complex.copySign(0, -z.im) : value.im);
+    }
+    static hyperbolicProduct(x, factor, odd) {
+        if (Math.abs(x) < 20) {
+            return factor * (odd ? Math.sinh(x) : Math.cosh(x));
+        }
+        const sign = odd ? factor * Math.sign(x) : factor;
+        if (factor === 0) {
+            return sign;
+        }
+        // Combine the factor before exponentiation to avoid a spurious Infinity * 0.
+        return Complex.copySign(Math.exp(Math.abs(x) - Math.LN2 + Math.log(Math.abs(factor))), sign);
+    }
+    static hyperbolicReciprocal(z, even) {
+        if (!Complex.isFinite(z)) {
+            return Complex.nan();
+        }
+        const x = Math.abs(z.re);
+        const q = Math.exp(-2 * x);
+        const difference = -Math.expm1(-2 * x);
+        const cos = Math.cos(z.im);
+        const sin = Math.sin(z.im);
+        const denominator = even
+            ? Complex.from(cos * (1 + q), sin * Complex.copySign(difference, z.re))
+            : Complex.from(cos * Complex.copySign(difference, z.re), sin * (1 + q));
+        return Complex.reciprocal(denominator).mul(Math.exp(Math.LN2 - x));
+    }
+    /**
+     * 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
+     */
+    static inverseHyperbolicParts(x, y) {
+        const plus = Math.hypot(x + 1, y);
+        const minus = Math.hypot(x - 1, y);
+        const a = plus / 2 + minus / 2;
+        const first = y === 0 ? 0 : y / Math.sqrt(plus + x + 1);
+        const second = y === 0 ? 0 : y / Math.sqrt(minus + Math.abs(x - 1));
+        const correction = Math.hypot(first, second) / Math.SQRT2;
+        const rootAMinus1 = x <= 1 ? correction : Math.hypot(Math.sqrt(x - 1), correction);
+        const rootAMinusX = x <= 1 ? Math.hypot(Math.sqrt(1 - x), correction) : correction;
+        return {
+            real: 2 * Math.asinh(rootAMinus1 / Math.SQRT2),
+            transverse: rootAMinusX * Math.sqrt(a + x),
+        };
+    }
+    static equals(z1, z2, epsilon = Number.EPSILON) {
+        return Math.abs(z1.re - z2.re) < epsilon && Math.abs(z1.im - z2.im) < epsilon;
+    }
+    static toPolar(z) {
+        return [z.abs(), z.arg()];
+    }
+    static toVector(z) {
+        return [z.re, z.im];
+    }
+    // TODO: format
+    static toString(z, dp = 3) {
+        const re = z.re.toFixed(dp);
+        const im = Math.abs(z.im).toFixed(dp);
+        const imsign = z.im < 0 ? '-' : '+';
+        return `${re} ${imsign} ${im}i`;
+    }
+}

package/dist/lib/components.d.ts

@@ -0,0 +1,14 @@
+/** An ideal series component equivalent to a reactance at one frequency. */
+export type ReactiveComponent = {
+    readonly kind: 'inductor';
+    readonly inductanceHenries: number;
+} | {
+    readonly kind: 'capacitor';
+    readonly capacitanceFarads: number;
+};
+/**
+ * Convert reactance in ohms at a frequency in Hz to an ideal series L or C.
+ * Zero frequency, zero reactance, or an unrepresentable component returns undefined.
+ * Non-finite reactance and negative/non-finite frequency throw RangeError.
+ */
+export declare function reactanceToComponent(reactanceOhms: number, frequencyHz: number): ReactiveComponent | undefined;

package/dist/lib/components.js

@@ -0,0 +1,26 @@
+/**
+ * Convert reactance in ohms at a frequency in Hz to an ideal series L or C.
+ * Zero frequency, zero reactance, or an unrepresentable component returns undefined.
+ * Non-finite reactance and negative/non-finite frequency throw RangeError.
+ */
+export function reactanceToComponent(reactanceOhms, frequencyHz) {
+    if (!Number.isFinite(reactanceOhms)) {
+        throw new RangeError('Reactance must be finite.');
+    }
+    if (!Number.isFinite(frequencyHz) || frequencyHz < 0) {
+        throw new RangeError('Frequency must be finite and non-negative.');
+    }
+    if (frequencyHz === 0 || reactanceOhms === 0) {
+        return;
+    }
+    // Compute in log space so intermediate products/quotients cannot overflow.
+    const logReactance = Math.log(Math.abs(reactanceOhms));
+    const logAngularFrequency = Math.log(2 * Math.PI) + Math.log(frequencyHz);
+    const value = Math.exp((reactanceOhms > 0 ? logReactance : -logReactance) - logAngularFrequency);
+    if (!Number.isFinite(value) || value === 0) {
+        return;
+    }
+    return reactanceOhms > 0
+        ? { kind: 'inductor', inductanceHenries: value }
+        : { kind: 'capacitor', capacitanceFarads: value };
+}