smithkit 0.4.0 → 0.5.0

package/dist/lib/traces/TraceLineDetail.js

@@ -0,0 +1,52 @@
+/** Nested radial-distance levels with a conservative accumulated error in Γ units. */
+export class TraceLineDetail {
+    levels = [];
+    constructor(data) {
+        if (data.length < 3) {
+            return;
+        }
+        // Reuse one scratch buffer; retained levels must shrink by at least 20%.
+        // This bounds cached index storage by a geometric series instead of levels × samples.
+        const scratch = new Uint32Array(data.length);
+        let previous;
+        let previousError = 0;
+        for (let exponent = -20; exponent <= 0; exponent++) {
+            const error = 2 ** exponent;
+            const allowance = error - previousError;
+            const squared = allowance * allowance;
+            const length = previous?.length ?? data.length;
+            let count = 1;
+            let last = 0;
+            scratch[0] = 0;
+            for (let position = 1; position < length - 1; position++) {
+                const index = previous ? previous[position] : position;
+                const dx = data.real(index) - data.real(last);
+                const dy = data.imaginary(index) - data.imaginary(last);
+                if (dx * dx + dy * dy > squared) {
+                    scratch[count++] = index;
+                    last = index;
+                }
+            }
+            scratch[count++] = data.length - 1;
+            if (count <= length * 0.8) {
+                previous = scratch.slice(0, count);
+                previousError = error;
+                this.levels.push({ error, indices: previous });
+            }
+            if (count === 2) {
+                break;
+            }
+        }
+    }
+    /** Undefined means use every sample. No data scan or allocation during view selection. */
+    select(tolerance) {
+        let indices;
+        for (const level of this.levels) {
+            if (level.error > tolerance) {
+                break;
+            }
+            indices = level.indices;
+        }
+        return indices;
+    }
+}

package/dist/lib/traces/TraceModel.d.ts

@@ -1,17 +1,18 @@
 import type { MarkerSelectionStrategy } from '../measurements.js';
 import type { Point } from '../math/geometry.js';
-import type { TraceSample, TraceSamples } from '../samples.js';
+import type { TraceInput } from '../samples.js';
+import { TraceBuffer } from './TraceBuffer.js';
 export interface TraceMarker {
     readonly number: number;
-    selectedPoint: TraceSample;
+    sampleIndex: number;
 }
 /** Owns validated samples and marker selections without depending on SVG or D3. */
 export declare class TraceModel {
     private samples;
     private markers;
     private markerCount;
-    constructor(samples: TraceSamples);
-    get Samples(): TraceSamples;
+    constructor(samples: TraceInput);
+    get Samples(): TraceBuffer;
     get Markers(): readonly TraceMarker[];
     addMarker(sampleIndex: number): TraceMarker;
     removeMarker(index: number): TraceMarker | undefined;
@@ -22,10 +23,7 @@ export declare class TraceModel {
     setMarkerFrequency(index: number, frequencyHz: number): TraceMarker | undefined;
     /** Returns false when dragging still selects the same sample. */
     selectNearestPoint(marker: TraceMarker, point: Readonly<Point>): boolean;
-    update(values: TraceSamples, strategy: MarkerSelectionStrategy): void;
+    update(values: TraceInput | TraceBuffer, strategy: MarkerSelectionStrategy): void;
     clear(): void;
-    private nearestFrequencyIndex;
-    private nearestPoint;
     private validateSampleIndex;
-    private copySamples;
 }

package/dist/lib/traces/TraceModel.js

@@ -1,10 +1,11 @@
+import { TraceBuffer } from './TraceBuffer.js';
 /** Owns validated samples and marker selections without depending on SVG or D3. */
 export class TraceModel {
     samples;
     markers = [];
     markerCount = 0;
     constructor(samples) {
-        this.samples = this.copySamples(samples);
+        this.samples = TraceBuffer.from(samples);
     }
     get Samples() {
         return this.samples;
@@ -14,7 +15,7 @@ export class TraceModel {
     }
     addMarker(sampleIndex) {
         this.validateSampleIndex(sampleIndex);
-        const marker = { number: ++this.markerCount, selectedPoint: this.samples[sampleIndex] };
+        const marker = { number: ++this.markerCount, sampleIndex };
         this.markers.push(marker);
         return marker;
     }
@@ -33,7 +34,7 @@ export class TraceModel {
     }
     markerSampleIndex(index) {
         const marker = this.markers[index];
-        return marker ? this.samples.indexOf(marker.selectedPoint) : -1;
+        return marker?.sampleIndex ?? -1;
     }
     setMarkerSample(index, sampleIndex) {
         const marker = this.markers[index];
@@ -41,7 +42,7 @@ export class TraceModel {
             return;
         }
         this.validateSampleIndex(sampleIndex);
-        marker.selectedPoint = this.samples[sampleIndex];
+        marker.sampleIndex = sampleIndex;
         return marker;
     }
     setMarkerFrequency(index, frequencyHz) {
@@ -51,73 +52,47 @@ export class TraceModel {
         if (!Number.isFinite(frequencyHz) || frequencyHz < 0) {
             throw new RangeError('Marker frequency must be finite and non-negative.');
         }
-        return this.setMarkerSample(index, this.nearestFrequencyIndex(frequencyHz));
+        return this.setMarkerSample(index, this.samples.nearestFrequency(frequencyHz));
     }
     /** Returns false when dragging still selects the same sample. */
     selectNearestPoint(marker, point) {
         if (!this.markers.includes(marker)) {
             return false;
         }
-        const sample = this.nearestPoint(point);
-        if (sample === marker.selectedPoint) {
+        const sampleIndex = this.samples.nearestPoint(point);
+        if (sampleIndex === marker.sampleIndex) {
             return false;
         }
-        marker.selectedPoint = sample;
+        marker.sampleIndex = sampleIndex;
         return true;
     }
     update(values, strategy) {
-        // Validate and copy before mutating either samples or marker selections.
-        const samples = this.copySamples(values);
-        const selectedIndices = this.markers.map((entry) => this.samples.indexOf(entry.selectedPoint));
-        this.samples = samples;
-        this.markers.forEach((entry, index) => {
+        // Prepare every selection before replacing data so rejected updates are atomic.
+        const samples = values instanceof TraceBuffer ? values : TraceBuffer.from(values);
+        const selectedIndices = this.markers.map((entry) => {
             if (strategy === 'sample-index') {
-                entry.selectedPoint = samples[Math.min(selectedIndices[index], samples.length - 1)];
-            }
-            else if (strategy === 'reflection') {
-                entry.selectedPoint = this.nearestPoint(entry.selectedPoint.reflectionCoefficient);
+                return Math.min(entry.sampleIndex, samples.length - 1);
             }
-            else {
-                entry.selectedPoint = samples[this.nearestFrequencyIndex(entry.selectedPoint.frequencyHz)];
+            if (strategy === 'reflection') {
+                return samples.nearestPoint([
+                    this.samples.real(entry.sampleIndex),
+                    this.samples.imaginary(entry.sampleIndex),
+                ]);
             }
+            return samples.nearestFrequency(this.samples.frequency(entry.sampleIndex));
+        });
+        this.samples = samples;
+        this.markers.forEach((entry, index) => {
+            entry.sampleIndex = selectedIndices[index];
         });
     }
     clear() {
-        this.samples = [];
+        this.samples = TraceBuffer.empty();
         this.markers = [];
     }
-    nearestFrequencyIndex(frequencyHz) {
-        let closest = 0;
-        let distance = Math.abs(this.samples[0].frequencyHz - frequencyHz);
-        for (let i = 1; i < this.samples.length; i++) {
-            const nextDistance = Math.abs(this.samples[i].frequencyHz - frequencyHz);
-            if (nextDistance < distance) {
-                closest = i;
-                distance = nextDistance;
-            }
-        }
-        return closest;
-    }
-    nearestPoint(point) {
-        const distance = (sample) => Math.hypot(point[0] - sample.reflectionCoefficient[0], point[1] - sample.reflectionCoefficient[1]);
-        return this.samples.reduce((previous, current) => distance(previous) <= distance(current) ? previous : current);
-    }
     validateSampleIndex(index) {
         if (!Number.isInteger(index) || index < 0 || index >= this.samples.length) {
             throw new RangeError('Sample index is outside this trace.');
         }
     }
-    copySamples(values) {
-        if (!values.length ||
-            values.some(({ frequencyHz, reflectionCoefficient }) => !Number.isFinite(frequencyHz) ||
-                frequencyHz < 0 ||
-                reflectionCoefficient.length !== 2 ||
-                !reflectionCoefficient.every(Number.isFinite))) {
-            throw new RangeError('A dataset requires samples with a non-negative finite frequency and two finite coordinates.');
-        }
-        return values.map(({ frequencyHz, reflectionCoefficient }) => ({
-            frequencyHz,
-            reflectionCoefficient: [reflectionCoefficient[0], reflectionCoefficient[1]],
-        }));
-    }
 }

package/dist/lib/traces/TraceRenderer.d.ts

@@ -1,7 +1,7 @@
 import { SmithGroup } from '../svg/SmithGroup.js';
 import { SmithScaler } from '../svg/SmithScaler.js';
 import type { TraceStyle } from '../measurements.js';
-import type { TraceSamples } from '../samples.js';
+import { TraceBuffer } from './TraceBuffer.js';
 export interface TraceTransform {
     x: number;
     y: number;
@@ -17,8 +17,18 @@ export declare class TraceRenderer {
     private viewportScale;
     private visible;
     private group;
-    constructor(data: TraceSamples, color: string, transform: TraceTransform, container: SmithGroup, scaler: SmithScaler, style?: Partial<TraceStyle>);
+    private lineDetail;
+    private lineIndices;
+    constructor(data: TraceBuffer, color: string, transform: TraceTransform, container: SmithGroup, scaler: SmithScaler, style?: Partial<TraceStyle>);
     private drawTrace;
+    private selectLineIndices;
+    private linePath;
+    private updateLine;
+    /** Replace geometry only in the export copy, never in the live SVG. */
+    fullExportLine(): {
+        node: SVGElement;
+        path: string;
+    } | undefined;
     private renderPoints;
     setViewportScale(scale: number): void;
     zoom(transform: TraceTransform): void;
@@ -28,6 +38,6 @@ export declare class TraceRenderer {
     setStyle(options: Partial<TraceStyle>): void;
     private redraw;
     setVisible(visible: boolean): void;
-    update(data: TraceSamples): void;
+    update(data: TraceBuffer): void;
     destroy(): void;
 }

package/dist/lib/traces/TraceRenderer.js

@@ -1,5 +1,7 @@
-import { line } from 'd3';
+import { path, pathRound } from 'd3';
 import { SmithGroup } from '../svg/SmithGroup.js';
+import { TraceLineDetail } from './TraceLineDetail.js';
+import { TraceBuffer } from './TraceBuffer.js';
 /** Draws a trace; sample validation and marker selection belong to TraceModel. */
 export class TraceRenderer {
     data;
@@ -10,6 +12,8 @@ export class TraceRenderer {
     viewportScale = 1;
     visible = true;
     group;
+    lineDetail;
+    lineIndices;
     constructor(data, color, transform, container, scaler, style = {}) {
         this.data = data;
         this.color = color;
@@ -19,6 +23,7 @@ export class TraceRenderer {
             mode: style.mode ?? 'points',
             lineWidth: style.lineWidth ?? 2,
             pointRadius: style.pointRadius ?? 2,
+            lineTolerancePx: style.lineTolerancePx ?? 0,
         };
         this.group = this.drawTrace(data).attr('pointer-events', 'none');
         container.append(this.group);
@@ -32,12 +37,10 @@ export class TraceRenderer {
         group.attr('data-role', 'samples');
         group.attr('data-mode', this.style.mode);
         if (this.style.mode !== 'points') {
-            const path = line()
-                .x((sample) => this.scaler.x(sample.reflectionCoefficient[0]))
-                .y((sample) => this.scaler.y(sample.reflectionCoefficient[1]));
+            this.lineIndices = this.selectLineIndices();
             group.Element.append('path')
                 .attr('class', 'trace-line')
-                .attr('d', path(data))
+                .attr('d', this.linePath(this.lineIndices))
                 .attr('fill', 'none')
                 .attr('stroke', this.color)
                 .attr('stroke-width', this.style.lineWidth)
@@ -50,32 +53,83 @@ export class TraceRenderer {
         }
         return group;
     }
+    selectLineIndices() {
+        if (this.style.lineTolerancePx === 0) {
+            return;
+        }
+        this.lineDetail ??= new TraceLineDetail(this.data);
+        const unitsToPixels = Math.max(Math.abs(this.scaler.x(1) - this.scaler.x(0)), Math.abs(this.scaler.y(1) - this.scaler.y(0))) *
+            this.transform.k *
+            this.viewportScale;
+        return this.lineDetail.select(this.style.lineTolerancePx / unitsToPixels);
+    }
+    linePath(indices) {
+        // Simplified paths retain numeric precision even at high zoom. Full paths keep
+        // the existing SVG serialization; the tolerance measures additional simplification.
+        const line = indices ? path() : pathRound(3);
+        const length = indices?.length ?? this.data.length;
+        for (let position = 0; position < length; position++) {
+            const index = indices ? indices[position] : position;
+            const x = this.scaler.x(this.data.real(index));
+            const y = this.scaler.y(this.data.imaginary(index));
+            if (position === 0) {
+                line.moveTo(x, y);
+            }
+            else {
+                line.lineTo(x, y);
+            }
+        }
+        if (length === 1) {
+            line.closePath();
+        }
+        return line.toString();
+    }
+    updateLine() {
+        if (this.style.mode === 'points') {
+            return;
+        }
+        const indices = this.selectLineIndices();
+        if (indices !== this.lineIndices) {
+            this.lineIndices = indices;
+            this.group.Element.select('.trace-line').attr('d', this.linePath(indices));
+        }
+    }
+    /** Replace geometry only in the export copy, never in the live SVG. */
+    fullExportLine() {
+        const node = this.group.Element.select('.trace-line').node();
+        if (node && this.lineIndices) {
+            return { node, path: this.linePath() };
+        }
+        return;
+    }
     renderPoints(group, data) {
-        let visible = data;
-        if (data.length > 5000) {
-            const cells = new Set();
-            const cellSize = Math.max(0.5, this.style.pointRadius) / this.viewportScale;
-            const extent = this.scaler.x(1);
-            const margin = this.style.pointRadius / this.viewportScale;
-            visible = data.filter((sample) => {
-                const x = this.scaler.x(sample.reflectionCoefficient[0]) * this.transform.k + this.transform.x;
-                const y = this.scaler.y(sample.reflectionCoefficient[1]) * this.transform.k + this.transform.y;
+        const visible = [];
+        const cells = new Set();
+        const cellSize = Math.max(0.5, this.style.pointRadius) / this.viewportScale;
+        const extent = this.scaler.x(1);
+        const margin = this.style.pointRadius / this.viewportScale;
+        const firstCell = Math.floor(-margin / cellSize);
+        const columns = Math.floor((extent + margin) / cellSize) - firstCell + 1;
+        for (let i = 0; i < data.length; i++) {
+            if (data.length > 5000) {
+                const x = this.scaler.x(data.real(i)) * this.transform.k + this.transform.x;
+                const y = this.scaler.y(data.imaginary(i)) * this.transform.k + this.transform.y;
                 if (x < -margin || y < -margin || x > extent + margin || y > extent + margin) {
-                    return false;
+                    continue;
                 }
-                const cell = `${Math.floor(x / cellSize)},${Math.floor(y / cellSize)}`;
+                const cell = (Math.floor(y / cellSize) - firstCell) * columns + Math.floor(x / cellSize) - firstCell;
                 if (cells.has(cell)) {
-                    return false;
+                    continue;
                 }
                 cells.add(cell);
-                return true;
-            });
+            }
+            visible.push(i);
         }
         group.Element.selectAll('circle')
             .data(visible)
             .join('circle')
-            .attr('cx', (sample) => this.scaler.x(sample.reflectionCoefficient[0]))
-            .attr('cy', (sample) => this.scaler.y(sample.reflectionCoefficient[1]))
+            .attr('cx', (index) => this.scaler.x(data.real(index)))
+            .attr('cy', (index) => this.scaler.y(data.imaginary(index)))
             .attr('r', this.style.pointRadius / (this.transform.k * this.viewportScale));
     }
     setViewportScale(scale) {
@@ -90,6 +144,7 @@ export class TraceRenderer {
         this.zoomDataPoints();
     }
     zoomDataPoints() {
+        this.updateLine();
         const k = this.transform.k;
         if (this.style.mode === 'line') {
             return;
@@ -114,10 +169,12 @@ export class TraceRenderer {
             mode: options.mode ?? this.style.mode,
             lineWidth: options.lineWidth ?? this.style.lineWidth,
             pointRadius: options.pointRadius ?? this.style.pointRadius,
+            lineTolerancePx: options.lineTolerancePx ?? this.style.lineTolerancePx,
         };
         if (next.mode === this.style.mode &&
             next.lineWidth === this.style.lineWidth &&
-            next.pointRadius === this.style.pointRadius) {
+            next.pointRadius === this.style.pointRadius &&
+            next.lineTolerancePx === this.style.lineTolerancePx) {
             return;
         }
         const modeChanged = next.mode !== this.style.mode;
@@ -143,10 +200,13 @@ export class TraceRenderer {
     }
     update(data) {
         this.data = data;
+        this.lineDetail = undefined;
         this.redraw();
     }
     destroy() {
-        this.data = [];
+        this.lineDetail = undefined;
+        this.lineIndices = undefined;
+        this.data = TraceBuffer.empty();
         this.group.Element.remove();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smithkit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Framework-independent, interactive Smith chart library for JavaScript and TypeScript",
   "type": "module",
   "scripts": {
@@ -21,7 +21,9 @@
     "format:check": "prettier . --check",
     "check:package": "node scripts/check-package.mjs",
     "check:example": "node scripts/check-example.mjs",
-    "prepare:release": "node scripts/prepare-release.mjs"
+    "prepare:release": "node scripts/prepare-release.mjs",
+    "benchmark:traces": "node scripts/benchmark-traces.mjs",
+    "benchmark:workloads": "node scripts/benchmark-workloads.mjs"
   },
   "dependencies": {
     "@types/d3": "^7.4.3",