velo-plot 1.11.1

package/dist/plugins/analysis/math.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Mathematical utilities for numerical analysis and regression.
+ */
+/**
+ * Solve a system of linear equations Ax = B using Gaussian elimination with partial pivoting.
+ *
+ * @param A - Matrix coefficients
+ * @param B - Right hand side vector
+ * @returns Solution vector x
+ */
+export declare function solveLinearSystem(A: number[][], B: number[]): number[];
+/**
+ * Calculate R² (coefficient of determination)
+ */
+export declare function calculateR2(x: number[] | Float32Array, y: number[] | Float32Array, fitFn: (x: number) => number): number;
+/**
+ * Numerical integration using the trapezoidal rule.
+ *
+ * @param x - X values (must be sorted)
+ * @param y - Y values
+ * @param xMin - Optional start of integration range
+ * @param xMax - Optional end of integration range
+ */
+export declare function integrate(x: number[] | Float32Array, y: number[] | Float32Array, xMin?: number, xMax?: number): number;
+/**
+ * Calculate numerical derivative dy/dx
+ */
+export declare function derivative(x: number[] | Float32Array, y: number[] | Float32Array): Float32Array;
+/**
+ * Calculate cumulative integral (area array)
+ */
+export declare function cumulativeIntegral(x: number[] | Float32Array, y: number[] | Float32Array): Float32Array;

package/dist/plugins/analysis/statistics.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Advanced Statistical Analysis
+ *
+ * Provides:
+ * - Cross-correlation
+ * - Auto-correlation
+ * - Anomaly detection
+ * - Statistical tests
+ * - Numerical integration (Simpson, trapezoidal)
+ */
+/** Cross-correlation result */
+export interface CorrelationResult {
+    /** Correlation values at each lag */
+    correlation: Float32Array;
+    /** Lag values */
+    lags: Float32Array;
+    /** Maximum correlation value */
+    maxCorrelation: number;
+    /** Lag at maximum correlation */
+    lagAtMax: number;
+}
+/**
+ * Compute cross-correlation between two signals
+ */
+export declare function crossCorrelation(signal1: Float32Array | Float64Array, signal2: Float32Array | Float64Array, maxLag?: number): CorrelationResult;
+/**
+ * Compute auto-correlation of a signal
+ */
+export declare function autoCorrelation(signal: Float32Array | Float64Array, maxLag?: number): CorrelationResult;
+/** Anomaly detection result */
+export interface AnomalyResult {
+    /** Indices of anomalous points */
+    indices: number[];
+    /** Anomaly scores for all points */
+    scores: Float32Array;
+    /** Threshold used for detection */
+    threshold: number;
+}
+/** Anomaly detection options */
+export interface AnomalyOptions {
+    /** Detection method */
+    method?: 'zscore' | 'mad' | 'iqr' | 'isolation';
+    /** Threshold multiplier (default: 3 for zscore, 2.5 for mad, 1.5 for iqr) */
+    threshold?: number;
+    /** Window size for local anomaly detection (default: use global) */
+    windowSize?: number;
+}
+/**
+ * Detect anomalies in a signal
+ */
+export declare function detectAnomalies(data: Float32Array | Float64Array, options?: AnomalyOptions): AnomalyResult;
+/**
+ * Trapezoidal integration
+ */
+export declare function trapezoidalIntegration(y: Float32Array | Float64Array, x?: Float32Array | Float64Array | number): number;
+/**
+ * Simpson's rule integration (requires odd number of points)
+ */
+export declare function simpsonsIntegration(y: Float32Array | Float64Array, x?: Float32Array | Float64Array | number): number;
+/**
+ * Cumulative integration (returns running integral)
+ */
+export declare function cumulativeIntegration(y: Float32Array | Float64Array, x?: Float32Array | Float64Array | number): Float32Array;
+/** T-test result */
+export interface TTestResult {
+    /** T-statistic */
+    tStatistic: number;
+    /** Degrees of freedom */
+    degreesOfFreedom: number;
+    /** Approximate p-value (two-tailed) */
+    pValue: number;
+    /** Whether the difference is significant at 0.05 level */
+    significant: boolean;
+}
+/**
+ * Two-sample t-test (Welch's t-test)
+ */
+export declare function tTest(sample1: Float32Array | Float64Array | number[], sample2: Float32Array | Float64Array | number[]): TTestResult;

package/dist/plugins/analysis/utils.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Data Analysis Utilities
+ *
+ * General-purpose utilities for scientific data formatting,
+ * cycle detection, peak detection, and data validation.
+ */
+type SIPrefix = 'p' | 'n' | 'µ' | 'm' | '' | 'k' | 'M' | 'G';
+export interface PrefixInfo {
+    symbol: SIPrefix;
+    factor: number;
+}
+/**
+ * Find the best SI prefix for a value
+ */
+export declare function getBestPrefix(value: number): PrefixInfo;
+/**
+ * Format a value with automatic SI prefix
+ *
+ * @example
+ * formatWithPrefix(0.000001, 'A') // "1.00 µA"
+ * formatWithPrefix(0.5, 'V')      // "500 mV"
+ * formatWithPrefix(1500, 'm')     // "1.50 km"
+ */
+export declare function formatWithPrefix(value: number, unit: string, decimals?: number): string;
+/**
+ * Format a numeric value with specified decimals
+ * Automatically switches to scientific notation for very large/small values
+ */
+export declare function formatValue(value: number, decimals?: number): string;
+/**
+ * Format value in scientific notation
+ */
+export declare function formatScientific(value: number, decimals?: number): string;
+export interface CycleInfo {
+    /** Cycle number (1-indexed) */
+    number: number;
+    /** Start index in data array */
+    startIndex: number;
+    /** End index in data array */
+    endIndex: number;
+    /** Direction at start: 1 = forward, -1 = reverse */
+    direction: 1 | -1;
+}
+/**
+ * Detect cycles in oscillating data
+ *
+ * A cycle is complete when the signal returns to its starting value
+ * after going through both sweep directions. Useful for:
+ * - Cyclic voltammetry data
+ * - Periodic signals
+ * - Oscillation analysis
+ *
+ * @param signal - The signal data (e.g., potential, position, etc.)
+ * @param tolerance - How close to starting value to consider a cycle complete
+ */
+export declare function detectCycles(signal: Float32Array | Float64Array | number[], tolerance?: number): CycleInfo[];
+/**
+ * Generate distinct colors for cycles/series
+ *
+ * Uses HSL color space to generate evenly distributed hues
+ */
+export declare function generateCycleColors(count: number): string[];
+export interface Peak {
+    /** Index in data array */
+    index: number;
+    /** X value at peak */
+    x: number;
+    /** Y value at peak */
+    y: number;
+    /** Peak type */
+    type: 'max' | 'min';
+    /** Prominence of the peak */
+    prominence: number;
+}
+/**
+ * Detect peaks (local maxima and minima) in data
+ *
+ * Uses simple local extrema detection with optional prominence filtering.
+ * Useful for:
+ * - Signal peak detection
+ * - Finding local maxima/minima
+ * - Feature extraction
+ *
+ * @param x - X values (independent variable)
+ * @param y - Y values (dependent variable)
+ * @param options - Detection options
+ */
+export declare function detectPeaks(x: Float32Array | Float64Array | number[], y: Float32Array | Float64Array | number[], options?: {
+    /** Minimum prominence to be considered a peak */
+    minProminence?: number;
+    /** Only return 'max' or 'min' peaks */
+    type?: 'max' | 'min' | 'both';
+}): Peak[];
+export interface ValidationResult {
+    /** Whether all data is valid */
+    valid: boolean;
+    /** Number of invalid values (NaN, Infinity, etc.) */
+    invalidCount: number;
+    /** Index of first invalid value (-1 if all valid) */
+    firstInvalidIndex: number;
+}
+/**
+ * Validate that data contains only finite numbers
+ *
+ * Checks for NaN, Infinity, and -Infinity values.
+ * Useful for data quality checks before rendering.
+ */
+export declare function validateData(data: Float32Array | Float64Array | number[]): ValidationResult;
+export interface DataStats {
+    min: number;
+    max: number;
+    mean: number;
+    stdDev: number;
+    count: number;
+}
+/**
+ * Calculate basic statistics for a dataset
+ */
+export declare function calculateStats(data: Float32Array | Float64Array | number[]): DataStats;
+/**
+ * Apply moving average smoothing to data
+ *
+ * @param data - Input data array
+ * @param windowSize - Number of points to average (must be odd)
+ */
+export declare function movingAverage(data: Float32Array | Float64Array | number[], windowSize: number): Float32Array;
+/**
+ * Downsample data using LTTB (Largest Triangle Three Buckets) algorithm
+ *
+ * Preserves visual characteristics while reducing point count.
+ * Ideal for rendering large datasets efficiently.
+ *
+ * @param x - X values
+ * @param y - Y values
+ * @param targetPoints - Desired number of output points
+ */
+export declare function downsampleLTTB(x: Float32Array | Float64Array, y: Float32Array | Float64Array, targetPoints: number): {
+    x: Float32Array;
+    y: Float32Array;
+};
+/**
+ * Subtract a linear baseline from data
+ *
+ * @param x - X data
+ * @param y - Y data
+ * @param x1 - Start of baseline segment
+ * @param x2 - End of baseline segment
+ */
+export declare function subtractBaseline(x: Float32Array | number[], y: Float32Array | number[], x1: number, x2: number): Float32Array;
+export {};

package/dist/plugins/analysis.d.ts

@@ -0,0 +1,3 @@
+export * from './analysis/index'
+import SciPlot from './analysis/index'
+export default SciPlot