smithkit 0.0.0-stage → 0.1.1

package/dist/lib/Smith.js

@@ -0,0 +1,562 @@
+import * as d3 from 'd3';
+import { MouseGesture } from './draw/MouseGesture.js';
+import { SmithSvg } from './draw/SmithSvg.js';
+import { SmithGroup } from './draw/SmithGroup.js';
+import { SmithCircle } from './draw/SmithCircle.js';
+import { SmithData } from './draw/SmithData.js';
+import { SmithCursor } from './draw/SmithCursor.js';
+import { ConstResistance } from './draw/ConstResistance.js';
+import { ConstReactance } from './draw/ConstReactance.js';
+import { ConstConductance } from './draw/ConstConductance.js';
+import { ConstSusceptance } from './draw/ConstSusceptance.js';
+import { ConstQCircles } from './draw/ConstQCircles.js';
+import { ConstSwrCircles } from './draw/ConstSwrCircles.js';
+import { SmithScaler } from './draw/SmithScaler.js';
+import { SmithConstantCircle } from './SmithConstantCircle.js';
+import { SmithArcsDefs } from './SmithArcsDefs.js';
+import { Complex } from './complex/Complex.js';
+import { SmithPeripheralScales } from './scales/SmithPeripheralScales.js';
+import { gridLayer, circleLayer } from './layers.js';
+import { renormalizeSamples } from './renormalization.js';
+import { readReflection } from './rf.js';
+import { compareMarkerReadings } from './measurements.js';
+export var SmithEventType;
+(function (SmithEventType) {
+    SmithEventType["Cursor"] = "cursor";
+    SmithEventType["Marker"] = "marker";
+    SmithEventType["MarkerDragStart"] = "marker-drag-start";
+    SmithEventType["MarkerDragEnd"] = "marker-drag-end";
+})(SmithEventType || (SmithEventType = {}));
+export class Smith {
+    referenceOhms;
+    calcs = new SmithConstantCircle();
+    scalers;
+    transform = d3.zoomIdentity;
+    zoomEnabled = true;
+    applyingView = false;
+    zoomBehavior = d3.zoom();
+    svg;
+    resizeObserver;
+    container;
+    dataContainer;
+    markerContainer;
+    reactanceAxis;
+    constResistance;
+    constReactance;
+    constConductance;
+    constSusceptance;
+    constSwrCircles;
+    constQCircles;
+    cursor;
+    peripheralScaleRenderer = new SmithPeripheralScales();
+    data = [];
+    destroyed = false;
+    mouseGesture = new MouseGesture();
+    nextDatasetColor = 0;
+    nextTraceId = 1;
+    nextMarkerId = 1;
+    traceMetadata = new WeakMap();
+    markerIds = new WeakMap();
+    draggedMarkers = new Set();
+    cursorBeforeMarkerDrag = null;
+    listeners = new Set();
+    layers;
+    peripheralScales;
+    constructor(referenceOhms = 50) {
+        this.referenceOhms = referenceOhms;
+        if (!Number.isFinite(referenceOhms) || referenceOhms <= 0) {
+            throw new RangeError('Reference impedance must be positive and finite.');
+        }
+        const viewBoxSize = 500;
+        const gridData = SmithArcsDefs.getData();
+        this.scalers = this.createScalers(viewBoxSize);
+        this.svg = new SmithSvg(viewBoxSize);
+        this.container = new SmithGroup();
+        this.constResistance = new ConstResistance({
+            data: gridData,
+            scaler: this.scalers.default,
+            showMinor: true,
+        });
+        this.constResistance.show();
+        this.constReactance = new ConstReactance({
+            data: gridData,
+            scaler: this.scalers.default,
+            showMinor: true,
+        });
+        this.constReactance.show();
+        this.constConductance = new ConstConductance({
+            data: gridData,
+            scaler: this.scalers.default,
+            showMinor: true,
+        });
+        this.constConductance.hide();
+        this.constSusceptance = new ConstSusceptance({
+            data: gridData,
+            scaler: this.scalers.default,
+            showMinor: true,
+        });
+        this.constSusceptance.hide();
+        this.constQCircles = new ConstQCircles(this.scalers.default);
+        this.constQCircles.hide();
+        this.constSwrCircles = new ConstSwrCircles(this.scalers.default);
+        this.constSwrCircles.hide();
+        this.cursor = this.initCursor();
+        const cursorContainer = this.cursorContainer();
+        this.reactanceAxis = this.drawReactanceAxis({
+            stroke: '#334155',
+            strokeWidth: '1',
+            fill: 'none',
+        });
+        this.dataContainer = new SmithGroup().attr('data-layer', 'samples');
+        this.markerContainer = new SmithGroup().attr('data-layer', 'markers');
+        // build chart
+        this.svg.append(this.container);
+        this.container.append(this.constConductance.draw().attr('data-layer', 'conductance'));
+        this.container.append(this.constSusceptance.draw().attr('data-layer', 'susceptance'));
+        this.container.append(this.constResistance.draw().attr('data-layer', 'resistance'));
+        this.container.append(this.constReactance.draw().attr('data-layer', 'reactance'));
+        this.container.append(this.constQCircles.draw());
+        this.container.append(this.constSwrCircles.draw());
+        this.container.append(this.peripheralScaleRenderer);
+        this.container.append(this.cursor.Group);
+        this.container.append(this.reactanceAxis);
+        this.container.append(cursorContainer);
+        this.container.append(this.dataContainer);
+        this.container.append(this.markerContainer);
+        const labels = new SmithGroup().attr('data-layer', 'labels').attr('pointer-events', 'none');
+        for (const [name, layer] of [
+            ['conductance', this.constConductance],
+            ['susceptance', this.constSusceptance],
+            ['resistance', this.constResistance],
+            ['reactance', this.constReactance],
+        ]) {
+            labels.append(layer.labels.attr('data-label-layer', name));
+        }
+        labels.append(this.peripheralScaleRenderer.labels);
+        this.container.append(labels);
+        const assertAlive = () => this.assertAlive();
+        this.layers = {
+            resistance: gridLayer(this.constResistance, assertAlive),
+            reactance: gridLayer(this.constReactance, assertAlive),
+            conductance: gridLayer(this.constConductance, assertAlive),
+            susceptance: gridLayer(this.constSusceptance, assertAlive),
+            q: circleLayer(this.constQCircles, 0, assertAlive),
+            vswr: circleLayer(this.constSwrCircles, 1, assertAlive),
+        };
+        this.peripheralScales = {
+            setVisible: (visible) => {
+                assertAlive();
+                if (visible) {
+                    this.peripheralScaleRenderer.show();
+                }
+                else {
+                    this.peripheralScaleRenderer.hide();
+                }
+            },
+            update: (gamma) => {
+                assertAlive();
+                this.peripheralScaleRenderer.update(gamma);
+            },
+        };
+        this.initializeZoom();
+        this.resizeObserver = new ResizeObserver(() => this.updateViewportScale());
+        this.resizeObserver.observe(this.svg.Node);
+    }
+    draw(target) {
+        this.assertAlive();
+        const host = typeof target === 'string' ? document.querySelector(target) : target;
+        if (!host) {
+            throw new Error('Chart container was not found.');
+        }
+        host.appendChild(this.svg.Node);
+        this.updateViewportScale();
+    }
+    /** Remove this chart and release its event handlers. Safe to call more than once. */
+    destroy() {
+        if (this.destroyed) {
+            return;
+        }
+        this.resizeObserver.disconnect();
+        this.listeners.clear();
+        this.clearTraces();
+        this.destroyed = true;
+        this.cursor.setMoveHandler(null);
+        this.mouseGesture.destroy();
+        this.zoomBehavior.on('start', null).on('zoom', null);
+        this.svg.Element.interrupt().on('.zoom', null);
+        this.svg.Element.selectAll('*').interrupt().on('.smithkit', null).on('.drag', null);
+        this.svg.Element.remove();
+    }
+    updateViewportScale() {
+        if (this.destroyed) {
+            return;
+        }
+        const matrix = this.svg.Node.getScreenCTM();
+        if (matrix) {
+            const scale = Math.hypot(matrix.a, matrix.b);
+            this.data.forEach((trace) => trace.setViewportScale(scale));
+        }
+    }
+    assertAlive() {
+        if (this.destroyed) {
+            throw new Error('This Smith chart has been destroyed. Create a new instance.');
+        }
+    }
+    createScalers(size) {
+        const impedance = new SmithScaler(d3.scaleLinear().domain([-1, 1]).range([0, size]), d3.scaleLinear().domain([1, -1]).range([0, size]), d3
+            .scaleLinear()
+            .domain([0, 1])
+            .range([0, size / 2]));
+        const admittance = new SmithScaler(d3.scaleLinear().domain([1, -1]).range([0, size]), d3.scaleLinear().domain([-1, 1]).range([0, size]), d3
+            .scaleLinear()
+            .domain([0, 1])
+            .range([0, size / 2]));
+        return { default: impedance, impedance, admittance };
+    }
+    cursorMove(p) {
+        if (this.draggedMarkers.size > 0) {
+            return;
+        }
+        this.cursor.Position = Complex.from(this.scalers.default.pointInvert(p));
+    }
+    markerDragChanged(marker, dragging) {
+        const wasDragging = this.draggedMarkers.size > 0;
+        if (dragging) {
+            this.draggedMarkers.add(marker);
+        }
+        else {
+            this.draggedMarkers.delete(marker);
+        }
+        const isDragging = this.draggedMarkers.size > 0;
+        if (isDragging === wasDragging) {
+            return;
+        }
+        if (isDragging) {
+            this.cursorBeforeMarkerDrag = this.svg.Node.style.getPropertyValue('cursor') || null;
+            this.svg.Element.style('cursor', 'grabbing').style('--smithkit-marker-cursor', 'grabbing');
+            this.cursor.hide();
+            this.emit({ type: SmithEventType.Cursor, data: undefined });
+        }
+        else {
+            this.svg.Element.style('cursor', () => this.cursorBeforeMarkerDrag).style('--smithkit-marker-cursor', null);
+            this.cursorBeforeMarkerDrag = null;
+        }
+    }
+    initCursor() {
+        const cursor = new SmithCursor(this.scalers.default);
+        cursor.Group.attr('class', 'smith-cursor');
+        cursor.setMoveHandler(() => {
+            this.emit({ type: SmithEventType.Cursor, data: this.cursorReading });
+        });
+        return cursor;
+    }
+    /** Last cursor position. Use cursor events to detect pointer leave. */
+    get cursorReading() {
+        return readReflection(this.cursor.Position, this.referenceImpedanceOhms);
+    }
+    initializeZoom() {
+        const zoom = this.zoomBehavior
+            .scaleExtent([0.6, 1000])
+            .filter((event) => this.zoomEnabled && (!event.ctrlKey || event.type === 'wheel') && !event.button)
+            .on('start', (event) => {
+            if (event.sourceEvent) {
+                this.mouseGesture.capture(event.sourceEvent, 'zoom');
+            }
+        })
+            .on('zoom', (event) => {
+            if (!this.zoomEnabled && !this.applyingView) {
+                // An already active mouse/touch gesture still needs its normal end event.
+                // Restore D3's view through its public API while that gesture finishes.
+                this.applyView(this.transform);
+                return;
+            }
+            this.onZoom(event.transform);
+        });
+        this.svg.Element.call(zoom);
+        this.resetView();
+    }
+    /** Enable or disable wheel, double-click, and mouse/touch zoom/pan. Keeps the current view. */
+    setZoomEnabled(enabled) {
+        this.assertAlive();
+        if (typeof enabled !== 'boolean') {
+            throw new TypeError('Zoom enabled must be a boolean.');
+        }
+        if (this.zoomEnabled === enabled) {
+            return;
+        }
+        this.zoomEnabled = enabled;
+        if (!enabled) {
+            this.svg.Element.interrupt();
+        }
+    }
+    applyView(transform) {
+        this.applyingView = true;
+        try {
+            this.svg.Element.call(this.zoomBehavior.transform, transform);
+        }
+        finally {
+            this.applyingView = false;
+        }
+    }
+    resetView() {
+        this.assertAlive();
+        const transform = d3.zoomIdentity.translate(62.5, 62.5).scale(0.75);
+        this.applyView(transform);
+    }
+    onZoom(transform) {
+        if (this.destroyed) {
+            return;
+        }
+        this.transform = transform;
+        this.container.Element.attr('transform', transform.toString());
+        this.data.forEach((d) => d.zoom(transform));
+    }
+    cursorContainer() {
+        const shape = this.drawReactanceAxis({ fill: 'transparent', stroke: 'none' });
+        shape.Element.style('pointer-events', 'all')
+            .on('pointermove.smithkit', (event) => {
+            this.cursorMove(d3.pointer(event));
+        })
+            .on('pointerleave.smithkit', () => {
+            this.cursor.hide();
+            this.emit({ type: SmithEventType.Cursor, data: undefined });
+        });
+        return shape;
+    }
+    drawReactanceAxis(opts) {
+        const c = this.calcs.resistanceCircle(0);
+        c.p[0] = this.scalers.default.x(c.p[0]);
+        c.p[1] = this.scalers.default.y(c.p[1]);
+        c.r = this.scalers.default.r(c.r);
+        return new SmithCircle(c, opts);
+    }
+    /** Add a named trace with one initial marker. Returns a chart-local, stable ID. */
+    addTrace(values, options = {}) {
+        this.assertAlive();
+        this.validateTraceOptions(options);
+        if (!values.length) {
+            throw new RangeError('A trace requires at least one sample.');
+        }
+        const data = this.createSmithData(values, this.nextDatasetColor, options);
+        this.nextDatasetColor++;
+        this.data.push(data);
+        this.updateViewportScale();
+        const id = this.traceMetadata.get(data).id;
+        this.setTraceOptions(id, options);
+        return id;
+    }
+    /** Detached metadata snapshots; IDs and marker display numbers survive removals. */
+    getTraces() {
+        return this.data.map((data) => ({
+            ...this.traceMetadata.get(data),
+            ...data.Style,
+            color: data.Color,
+            visible: data.Visible,
+            sampleCount: data.SampleCount,
+            markers: data.Markers.map((entry, index) => ({
+                id: this.markerId(entry.marker),
+                number: entry.number,
+                sampleIndex: data.markerSampleIndex(index),
+            })),
+        }));
+    }
+    traceIndex(id) {
+        return this.data.findIndex((data) => this.traceMetadata.get(data).id === id);
+    }
+    markerId(marker) {
+        let id = this.markerIds.get(marker);
+        if (!id) {
+            id = `marker-${this.nextMarkerId++}`;
+            this.markerIds.set(marker, id);
+        }
+        return id;
+    }
+    findMarker(id) {
+        for (const [datasetNo, data] of this.data.entries()) {
+            const markerNo = data.Markers.findIndex((entry) => this.markerId(entry.marker) === id);
+            if (markerNo >= 0) {
+                return { datasetNo, markerNo };
+            }
+        }
+        return;
+    }
+    validateTraceOptions(options) {
+        if (options.mode !== undefined && !['points', 'line', 'both'].includes(options.mode)) {
+            throw new TypeError('Trace mode must be points, line, or both.');
+        }
+        for (const key of ['lineWidth', 'pointRadius']) {
+            const value = options[key];
+            if (value !== undefined && (!Number.isFinite(value) || value <= 0)) {
+                throw new RangeError(`${key} must be positive and finite.`);
+            }
+        }
+        if (options.name !== undefined && (typeof options.name !== 'string' || !options.name.trim())) {
+            throw new TypeError('Trace name must not be empty.');
+        }
+        if (options.color !== undefined &&
+            (typeof options.color !== 'string' || !d3.color(options.color))) {
+            throw new TypeError('Trace color must be a solid CSS color.');
+        }
+        if (options.visible !== undefined && typeof options.visible !== 'boolean') {
+            throw new TypeError('Trace visibility must be a boolean.');
+        }
+    }
+    setTraceOptions(id, options) {
+        this.assertAlive();
+        const data = this.data[this.traceIndex(id)];
+        if (!data) {
+            return false;
+        }
+        this.validateTraceOptions(options);
+        data.setStyle(options);
+        if (options.name !== undefined) {
+            this.traceMetadata.get(data).name = options.name.trim();
+        }
+        if (options.color !== undefined) {
+            data.setColor(options.color);
+        }
+        if (options.visible !== undefined) {
+            data.setVisible(options.visible);
+        }
+        return true;
+    }
+    /** Replace samples; by default each marker follows its nearest measured frequency. */
+    updateTrace(id, values, options = {}) {
+        this.assertAlive();
+        const data = this.data[this.traceIndex(id)];
+        if (!data) {
+            return false;
+        }
+        const strategy = options.markerSelection ?? 'frequency';
+        if (!['frequency', 'sample-index', 'reflection'].includes(strategy)) {
+            throw new TypeError('Marker selection must be frequency, sample-index, or reflection.');
+        }
+        data.update(values, strategy);
+        return true;
+    }
+    removeTrace(id) {
+        this.assertAlive();
+        const index = this.traceIndex(id);
+        if (index < 0) {
+            return false;
+        }
+        this.data[index].destroy();
+        this.data.splice(index, 1);
+        return true;
+    }
+    /** Place a marker on an existing sample; no interpolation is performed. */
+    addMarker(traceId, sampleIndex = 0) {
+        this.assertAlive();
+        const data = this.data[this.traceIndex(traceId)];
+        if (!data) {
+            return;
+        }
+        const index = data.addMarker(sampleIndex);
+        return this.markerId(data.Markers[index].marker);
+    }
+    removeMarker(id) {
+        this.assertAlive();
+        const location = this.findMarker(id);
+        return location ? this.data[location.datasetNo].removeMarker(location.markerNo) : false;
+    }
+    setMarkerSample(id, sampleIndex) {
+        this.assertAlive();
+        const location = this.findMarker(id);
+        return location
+            ? this.data[location.datasetNo].setMarkerSample(location.markerNo, sampleIndex)
+            : false;
+    }
+    /** Select the nearest measured frequency; ties choose the earliest input sample. */
+    setMarkerFrequency(id, frequencyHz) {
+        this.assertAlive();
+        const location = this.findMarker(id);
+        return location
+            ? this.data[location.datasetNo].setMarkerFrequency(location.markerNo, frequencyHz)
+            : false;
+    }
+    getMarker(id) {
+        const location = this.findMarker(id);
+        if (!location) {
+            return;
+        }
+        const data = this.data[location.datasetNo];
+        const marker = data.Markers[location.markerNo];
+        return {
+            ...readReflection(Complex.from(...marker.selectedPoint.reflectionCoefficient), this.referenceImpedanceOhms),
+            frequencyHz: marker.selectedPoint.frequencyHz,
+            traceId: this.traceMetadata.get(data).id,
+            markerId: id,
+            markerNumber: marker.number,
+            sampleIndex: data.markerSampleIndex(location.markerNo),
+        };
+    }
+    /** Return B − A, or undefined if either marker no longer exists. */
+    compareMarkers(a, b) {
+        const first = this.getMarker(a);
+        const second = this.getMarker(b);
+        return first && second ? compareMarkerReadings(first, second) : undefined;
+    }
+    /** Current positive real reference impedance, in ohms. */
+    get referenceImpedanceOhms() {
+        return this.referenceOhms;
+    }
+    /** Renormalize all traces while retaining physical impedance, IDs, and selected sample indices. */
+    renormalize(referenceImpedanceOhms) {
+        this.assertAlive();
+        // Validate even with no traces, and prepare every result before changing any state.
+        renormalizeSamples([], this.referenceOhms, referenceImpedanceOhms);
+        if (referenceImpedanceOhms === this.referenceOhms) {
+            return;
+        }
+        const samples = this.data.map((data) => renormalizeSamples(data.Samples, this.referenceOhms, referenceImpedanceOhms));
+        this.data.forEach((data) => data.Markers.forEach((entry) => entry.marker.cancelDrag()));
+        this.referenceOhms = referenceImpedanceOhms;
+        this.data.forEach((data, index) => data.update(samples[index], 'sample-index'));
+        this.cursor.hide();
+        this.emit({ type: SmithEventType.Cursor, data: undefined });
+    }
+    clearTraces() {
+        this.assertAlive();
+        this.data.forEach((dataset) => dataset.destroy());
+        this.data = [];
+    }
+    createSmithData(values, dataset, options) {
+        const color = d3.schemeCategory10[(1 + dataset) % d3.schemeCategory10.length];
+        const data = new SmithData(values, color, this.transform, this.dataContainer, this.scalers.default, (marker, dragging) => {
+            this.markerDragChanged(marker, dragging);
+            const snapshot = this.getMarker(this.markerId(marker));
+            if (snapshot) {
+                this.emit({
+                    type: dragging ? SmithEventType.MarkerDragStart : SmithEventType.MarkerDragEnd,
+                    data: snapshot,
+                });
+            }
+        }, this.markerContainer, options);
+        const number = this.nextTraceId++;
+        this.traceMetadata.set(data, { id: `trace-${number}`, name: `Trace ${number}` });
+        data.setMarkerMoveHandler((index) => {
+            const marker = data.Markers[index];
+            const snapshot = marker && this.getMarker(this.markerId(marker.marker));
+            if (snapshot) {
+                this.emit({ type: SmithEventType.Marker, data: snapshot });
+            }
+        });
+        data.addMarker();
+        return data;
+    }
+    /** Subscribe to chart events. The returned function removes this subscription. */
+    onEvent(listener) {
+        this.assertAlive();
+        // Separate registrations of the same function remain independently removable.
+        const subscription = (event) => listener(event);
+        this.listeners.add(subscription);
+        return () => {
+            this.listeners.delete(subscription);
+        };
+    }
+    emit(event) {
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+    }
+}

package/dist/lib/SmithArcsDefs.d.ts

@@ -0,0 +1,10 @@
+import { createGridDefinitions } from './grid/definitions.js';
+import { resistanceLabels, reactanceLabels } from './grid/labels.js';
+export { SmithArcEntry } from './grid/types.js';
+export type { SmithArcDef, SmithTickDef, SmithTicksShapes, SmithTicksData } from './grid/types.js';
+export declare class SmithArcsDefs {
+    private constructor();
+    static getData: typeof createGridDefinitions;
+    static resistanceLabels: typeof resistanceLabels;
+    static reactanceLabels: typeof reactanceLabels;
+}

package/dist/lib/SmithArcsDefs.js

@@ -0,0 +1,10 @@
+import { createGridDefinitions } from './grid/definitions.js';
+import { resistanceLabels, reactanceLabels } from './grid/labels.js';
+// Compatibility facade; definitions and label rules are independent of SVG rendering.
+export { SmithArcEntry } from './grid/types.js';
+export class SmithArcsDefs {
+    constructor() { }
+    static getData = createGridDefinitions;
+    static resistanceLabels = resistanceLabels;
+    static reactanceLabels = reactanceLabels;
+}

package/dist/lib/SmithConstantCircle.d.ts

@@ -0,0 +1,62 @@
+import { Circle } from './shapes/Circle.js';
+import { Point } from './shapes/Point.js';
+import { Complex } from './complex/Complex.js';
+export declare class SmithConstantCircle {
+    Z0: number;
+    constructor(Z0?: number);
+    rflCoeffToImpedance(c: Complex): Complex | undefined;
+    impedanceToRflCoeff(c: Complex): Complex | undefined;
+    rflCoeffToAdmittance(c: Complex): Complex | undefined;
+    admittanceToRflCoeff(c: Complex): Complex | undefined;
+    private transform;
+    resistanceCircle(n: number): Circle;
+    reactanceCircle(n: number): Circle;
+    conductanceCircle(n: number): Circle;
+    susceptanceCircle(n: number): Circle;
+    constQCircle(q: number): Circle;
+    rflCoeffToSwr(rc: Complex): number;
+    rflCoeffToDBS(rc: Complex): number;
+    swrToRflCoeffEOrI(swr: number): number;
+    swrTodBS(swr: number): number;
+    dBSToSwr(dBS: number): number;
+    dBSToAbsRflCoeff(dBS: number): number;
+    rflCoeffToReturnLoss(rc: Complex): number;
+    returnLossToRflCoeffEOrI(rl: number): number;
+    /** One-way attenuation scale, referenced to a fully reflecting termination. */
+    rflCoeffToAttenuation(rc: Complex): number;
+    attenuationToRflCoeff(attenuation: number): number;
+    rflCoeffToMismatchLoss(rc: Complex): number;
+    mismatchLossToRflCoeffEOrI(ml: number): number;
+    rflCoeffEOrI(rc: Complex): number;
+    rflCoeffP(rc: Complex): number;
+    rflCoeffPToEOrI(p: number): number;
+    rflCoeffToQ(rc: Complex): number | undefined;
+    rflCoeffToTransmCoeffP(rc: Complex): number;
+    transmCoeffPToRflCoeffEOrI(tcp: number): number;
+    rflCoeffToTransmCoeff(rc: Complex): Complex;
+    transmCoeffToRflCoeff(tc: Complex): Complex;
+    rflCoeffToTransmCoeffEOrI(rc: Complex): number;
+    /** Current transmission magnitude using the voltage reflection coefficient. */
+    rflCoeffToCurrentTransmission(rc: Complex): number;
+    rflCoeffToSwPeakConstP(rc: Complex): number;
+    swPeakConstPToRflCoeffEOrI(swPeak: number): number;
+    rflCoeffToSwLossCoeff(rc: Complex): number;
+    swLossCoeffToRflCoeffEOrI(swl: number): number;
+    circleCircleIntersection(c1: Circle, c2: Circle): Point[];
+    isPointWithinCircle(p: Point, c: Circle): boolean;
+    normalize(c: Complex): Complex;
+    denormalize(c: Complex): Complex;
+    waveLengthFromFrequency(frequency: number): number;
+    frequencyFromWaveLength(waveLength: number): number;
+    magnitude(c: Complex): number;
+    dB(value: number): number;
+    reactanceToCapacitance(x: number, f: number): number | null;
+    capacitanceToReactance(C: number, f: number): Complex;
+    reactanceToInductance(x: number, f: number): number | null;
+    inductanceToReactance(L: number, f: number): Complex;
+    addImpedance(rc: Complex, imp: Complex): Complex | undefined;
+    addAdmittance(rc: Complex, adm: Complex): Complex | undefined;
+    tangentToCircleAngle(c: Circle, p: Point): number;
+    rad2deg(rad: number): number;
+    deg2rad(deg: number): number;
+}