@danielsimonjr/mathts-functions 0.71.0 → 0.73.0

package/dist/scalar-search.d.ts

@@ -3,19 +3,29 @@
  *
  * `populations` islands each evolve by tournament selection and
  * {@link weightedMutation}. Each generation breeds `populationSize` offspring per
- * island from tournament winners, evaluates them in one batch, and keeps the best
- * `populationSize` distinct trees of parents and offspring (elitist truncation, not
- * age-based replacement). After every generation the islands exchange their
- * best trees (migration). A hall of fame shared by every island keeps the best tree
- * per complexity; its Pareto front is reported through {@link paretoFront} and
- * {@link scoreFront}.
+ * island from tournament winners, evaluates every island's batch at the same time
+ * (the score calls overlap in this process when worker scoring is in use; each
+ * island keeps its own rng; without `parallel`, or below the row threshold, scoring
+ * stays on the caller thread and overlap buys no throughput), and
+ * keeps the best `populationSize` distinct trees of parents and offspring per
+ * island (elitist truncation, not age-based replacement), applied in island-index
+ * order after every island's batch has finished. After every generation the islands
+ * exchange their best trees (migration). A hall of fame shared by every island keeps the best loss
+ * per complexity among stored trees and one evaluated tree per {@link scalarCanonicalKey}
+ * (loss first, then complexity, then first recorded); its Pareto front is reported
+ * through {@link paretoFront} and {@link scoreFront}. Subtree crossover
+ * ({@link crossoverSubtrees}) is opt-in:
+ * {@link ScalarSearchOptions.crossoverProbability} defaults to 0, so the
+ * offspring loop stays mutation-only and the default random stream is unchanged.
  *
  * @packageDocumentation
  */
 import { type SeededRng } from '@danielsimonjr/mathts-core';
-import { type ScalarGrammar, type ScalarNode } from '@danielsimonjr/mathts-expression';
+import { type ScalarComplexityWeights, type ScalarGrammar, type ScalarNode } from '@danielsimonjr/mathts-expression';
+import { type NamedScalarLoss } from './fit-scalar.js';
 import { type ScoredCandidate } from './pareto-front.js';
 import { type ScalarPopulationParallelOptions } from './scalar-batch-parallel.js';
+import { type RationalDimension } from './scalar-dimension.js';
 /** Columnar regression target for {@link searchScalars}. */
 export interface ScalarSearchProblem {
     /** Names of the input columns, in the order of `columns`. */
@@ -27,6 +37,34 @@ export interface ScalarSearchProblem {
     /** Fitted constants. Defaults to `grammar.parameters`. */
     readonly parameters?: readonly string[];
 }
+/**
+ * Opt-in SI dimension filter for the scalar search
+ * ({@link ScalarSearchOptions.dimensions}).
+ *
+ * `symbols` binds variable and parameter names to dimensions. A name omitted
+ * from `symbols` is a solver unknown when it is a parameter and
+ * `unknown-symbol` when it is a variable. `target` is the dimension the scored
+ * tree's root must have. `onUnderdetermined` decides a solve whose parameter
+ * dimensions are not fixed by the equations implied by the tree: `'keep'` (the
+ * default) scores the tree normally — for example `x^p` with a free exponent
+ * parameter stays scorable under any `target` because the solver does not assign
+ * a unique dimension to `p`. `'reject'` scores it `Infinity`. Listed grammar
+ * parameters that do not appear in the tree are ignored for underdetermined
+ * detection. Before the first yield the filter is copied into a frozen snapshot
+ * (plain-data `symbols` only, same rules as `complexityWeights`).
+ */
+export interface ScalarDimensionFilter {
+    readonly symbols: Readonly<Record<string, RationalDimension>>;
+    readonly target: RationalDimension;
+    readonly onUnderdetermined?: 'keep' | 'reject';
+    /** Caller equality for the inferred root dimension and `target` (infer mode only). A `false` result or a throw scores `Infinity`. Omitted: exact per-axis equality. */
+    readonly equal?: (left: RationalDimension, right: RationalDimension) => boolean;
+}
+/**
+ * When adaptive parsimony records offspring complexities within one generation.
+ * @internal Test hook only; not on the package barrel.
+ */
+export type FrequencyRecordTiming = 'island-boundary' | 'after-merge' | 'per-offspring';
 /** Budget and evolution knobs for {@link searchScalars}. */
 export interface ScalarSearchOptions {
     readonly grammar: ScalarGrammar;
@@ -40,11 +78,116 @@ export interface ScalarSearchOptions {
     readonly tournamentP?: number;
     /** Chance that an evaluated tree has its parameters refitted. Default 0.14. */
     readonly optimizeProbability?: number;
+    /**
+     * Residual loss for ranking and for every refit. Default `'l2'`: today's sum of
+     * squares, including `+Infinity` when any row is invalid. `'l1'` and `'huber'`
+     * reuse {@link fitScalarParameters}'s named losses. Omitted is the default
+     * branch, so the seed-7 pin is unchanged.
+     */
+    readonly loss?: NamedScalarLoss;
+    /**
+     * Per-row weights for that loss. Length must equal `observed.length`; every
+     * weight is finite and `>= 0`. A zero weight drops that row. Omitted: every
+     * row weighs 1.
+     */
+    readonly rowWeights?: Float64Array;
+    /**
+     * How a tree that is invalid on at least one row is ranked. Default `'reject'`:
+     * today's `+Infinity` — such a tree never enters the hall. `'penalize'` scores
+     * {@link INVALID_ROW_PENALTY} (the fitter's existing invalid-row penalty) times
+     * the number of invalid rows a positive `rowWeights` entry covers, plus the
+     * chosen `loss` on the valid rows; a zero-weight row is dropped on both sides.
+     * A tree with no valid row reports the penalty times the number of positively
+     * weighted rows (each invalid among them adds one penalty). The penalty is
+     * absolute, not scaled to the target magnitude. The ranker adds that sum on top
+     * of the valid-row loss; the fitter's reported loss counts only valid rows and
+     * freezes invalid rows with a squared penalty inside LM — different objectives.
+     * Refit acceptance compares both sides with {@link scoreOnProblem} / the ranker.
+     * Omitted is the default branch, so the seed-7 pin is unchanged.
+     */
+    readonly invalidRows?: 'reject' | 'penalize';
+    /**
+     * Per-node weights for the complexity the hall, the truncation tie-break, and
+     * adaptive parsimony rank by. `ScalarComplexityWeights` from
+     * `@danielsimonjr/mathts-expression`; omitted fields weigh 1, so `{}` (and an
+     * omitted option) is today's node count. Weights are normalized once before the
+     * first yield into a frozen snapshot; only plain data objects are accepted at
+     * the top level and on `op`, `call`, and per-name `symbol` records (prototype
+     * `Object.prototype` or `null`). Own keys are read exactly once via
+     * `Reflect.ownKeys`; non-enumerable keys and accessor properties throw
+     * `RangeError`. Every weight must be a finite number; weights that would make
+     * `grammar.maxSize` nodes sum to a non-finite complexity also throw before the
+     * first yield. Zero and negative weights are accepted: they are summed and
+     * `Math.round`ed by `scalarComplexity` like any other weight. Nested record
+     * keys must use lowered call names (`ln` is stored as `log`); unknown keys are
+     * kept in the snapshot but ignored at scoring time.
+     */
+    readonly complexityWeights?: ScalarComplexityWeights;
+    /**
+     * Refit knobs forwarded to {@link fitScalarParameters}. An omitted field is
+     * today's call: `restarts` 2, `maxIterations` 8, no bounds, the fitter's
+     * default algorithm, and `initial` set to the inherited vector (ones for the
+     * initial population). The values are forwarded, not reimplemented; a bad
+     * bound or length throws the fitter's `RangeError` before the first yield.
+     */
+    readonly fit?: ScalarFitOptions;
+    /**
+     * Chance that an offspring is a subtree crossover of two tournament parents
+     * instead of a mutation of the first. Default 0: the coin is not drawn, so the
+     * random stream matches a search that never had this option. In (0, 1] the
+     * island stream draws the coin; on success a second parent is drawn with the
+     * same tournament, {@link crossoverSubtrees} runs, and the child is kept when
+     * it is non-null and the grammar (including `admit`) accepts it. Otherwise the search falls
+     * through to the existing mutation attempts. The inherited parameter vector
+     * is always the first parent's.
+     */
+    readonly crossoverProbability?: number;
+    /**
+     * Simplify each seed and each bred offspring once, before the grammar check and
+     * the score, so the scored tree is the tree whose parameters are fitted. Default
+     * `'off'`: neither simplifier runs and the seed-7 pin is unchanged. `'constants'`
+     * folds numeric-only subtrees ({@link simplifyConstants}). `'algebraic'` runs the
+     * expression simplifier ({@link simplifyScalar}); when it throws
+     * `ScalarBuildError`, or its result fails the grammar (including `admit`), the
+     * tree keeps its unsimplified shape. Trees that come out of `enumerateScalars`
+     * are not simplified. Simplification draws no random numbers, but different
+     * accepted trees can change how many mutation attempts succeed, so a run with
+     * `simplify` on may diverge from an otherwise identical run with `'off'`; two
+     * runs that share the same `simplify` mode and seed still match. Progress event
+     * count stays budget-driven (`maxEvaluations`). When the simplified tree fails
+     * the grammar, changes the valid/invalid pattern on a positively weighted row,
+     * or disagrees in value within tolerance on such a row, the unsimplified tree
+     * is kept. `admit` runs on the simplified tree when its canonical key differs;
+     * a no-op fold (same key) is checked once. Algebraic simplification costs
+     * milliseconds per tree; the option stays off by default and no speed claim is
+     * made here.
+     */
+    readonly simplify?: 'off' | 'constants' | 'algebraic';
+    /**
+     * Opt-in SI dimension filter. Omitted: no dimension walk and the seed-7 pin is
+     * unchanged. Set: after the grammar check (and any simplification) and before
+     * the score, the tree that will be scored is checked. With parameters the
+     * check is {@link solveParameterDimensions} when the fitted parameter list is
+     * non-empty; an empty `problem.parameters` array forces infer mode even when
+     * the grammar lists parameters. Without fitted parameters the check is
+     * {@link inferScalarDimension}. In both modes the inferred or solved root
+     * dimension must equal `target`.
+     * An `add-mismatch`, `transcendental-arg-not-dimensionless`,
+     * `non-literal-exponent-on-dimensional-base`, or `unknown-symbol` violation,
+     * or an `inconsistent` solve, scores `Infinity` and never enters the hall —
+     * the same bucket as a numerical failure — but still counts as an evaluation.
+     * An underdetermined solve is scored normally (`'keep'`, the default) or
+     * scored `Infinity` (`'reject'`). The check draws no random numbers.
+     */
+    readonly dimensions?: ScalarDimensionFilter;
     /** Cap on tree evaluations, the initial population included. */
     readonly maxEvaluations: number;
     /** Second cap on tree evaluations, reported as `'max-candidates'`. */
     readonly maxCandidates?: number;
-    /** Trees injected into the initial population (`seeds`); the grammar filters them. */
+    /**
+     * Trees injected into the initial population (`seeds`). The grammar's structural
+     * rules filter them, and so does `grammar.admit` when it is set.
+     */
     readonly seeds?: readonly ScalarNode[];
     /** Constant-perturbation scale handed to the mutations. Default 0.25. */
     readonly perturbationFactor?: number;
@@ -53,9 +196,17 @@ export interface ScalarSearchOptions {
     /**
      * Independent islands, each with `populationSize` trees and its own random stream
      * (`rng.fork('island:' + index)`). Default 1, which draws from `rng.fork('population')`.
-     * Evaluations are counted across all islands.
+     * Evaluations are counted across all islands. The islands' score calls overlap
+     * within one generation when worker scoring is active; without `parallel`, or below
+     * the row threshold, evaluation stays on the caller thread and overlap does not
+     * increase throughput. The merge after the scores runs in island-index order.
      */
     readonly populations?: number;
+    /**
+     * @internal Test hook only: when offspring complexities reach the adaptive-parsimony
+     * window within a generation. Default `island-boundary` matches the sequential schedule.
+     */
+    readonly frequencyRecordTiming?: FrequencyRecordTiming;
     /**
      * Expected share of each island replaced by another island's best trees after every
      * generation, in [0, 1]. The count is the expectation rounded at random. Default 0.00036
@@ -83,11 +234,74 @@ export interface ScalarSearchOptions {
      * 100 rows; below that, and when omitted, evaluation stays on the caller thread. The
      * workers return the values the caller thread would compute, bit for bit, and parameter
      * refits and every random draw stay on the caller thread, so a parallel run equals the
-     * serial run for the same seed. `timeoutMs` (default 30000, must be positive) bounds each
-     * worker call. A `pool` you pass is yours to terminate; without one the search starts a
-     * pool when it first needs it and terminates it when the generator finishes or is closed.
+     * serial run for the same seed. Overlapped islands only overlap worker score calls; the
+     * caller-thread path does not gain throughput from SR-13. `timeoutMs` (default 30000,
+     * must be positive) bounds each worker task, including time queued behind other islands'
+     * submissions in the same generation — scale it with `populations` when several islands
+     * score together. A `pool` you pass is yours to terminate; without one the search starts
+     * a pool when it first needs it and terminates it when the generator finishes or is closed.
      */
     readonly parallel?: ScalarPopulationParallelOptions;
+    /**
+     * Cancellation signal (SR-15). The search checks it before the initial population
+     * and between generations, never in the middle of a random draw or a scored batch.
+     * Already aborted before the first yield: the result has an empty front,
+     * `evaluations: 0`, and `stopReason: 'cancelled'`. Aborted after a yield: the
+     * generator returns the last progress as the result with `stopReason: 'cancelled'`
+     * and does not start another generation (a generation that was already breeding
+     * and scoring runs to completion first). A pool the search owns is still
+     * terminated. Omitted: no cancellation and the seed-7 pin is unchanged.
+     */
+    readonly signal?: AbortSignal;
+    /**
+     * Optional early stop (SR-15). Omitted: the search always runs to
+     * `max-evaluations` (or `'max-candidates'`). Set: after a generation whose best
+     * finite hall loss is `<= loss`, and that has stayed true for `generations`
+     * consecutive generations, the search returns `stopReason: 'early-stop'` after
+     * yielding that generation's progress. The streak is counted over the hall after
+     * the generation (the initial population included), and it resets when a
+     * generation leaves the best loss above `loss` — the best hall loss can only
+     * improve, so a reset happens only while the hall is still empty or the best
+     * loss has not yet reached `loss`. `loss` must be finite and `generations` an
+     * integer `>= 1` (`RangeError` otherwise). A run that never reaches `loss`
+     * still ends on `'max-evaluations'`.
+     */
+    readonly earlyStop?: {
+        readonly loss: number;
+        readonly generations: number;
+    };
+    /**
+     * Factor forwarded to {@link selectFrontModel}'s `bestLossFactor` when
+     * `modelSelection` is set (SR-16). Omitted: the factor `selectFrontModel`
+     * already defaults to (1.5), so today's call is unchanged. A non-finite value
+     * throws `RangeError` before the search starts, even when `modelSelection` is
+     * omitted. Only read when `modelSelection` is set. Values in `(0, 1)` can make
+     * the `'best'` filter keep no row once selection runs, which throws
+     * {@link ParetoFrontError} mid-run; `1` is the safe lower boundary (only
+     * minimum-loss rows qualify).
+     */
+    readonly bestLossFactor?: number;
+}
+/** Budget, bounds, and start-vector knobs for the search's parameter refits. */
+export interface ScalarFitOptions {
+    /** Restarted fits per refit. Default 2. Must be an integer >= 0. */
+    readonly restarts?: number;
+    /** Optimizer iterations per fit. Default 8. Must be an integer >= 0. */
+    readonly maxIterations?: number;
+    /**
+     * One `[lo, hi]` pair per parameter. Endpoints are finite or `±Infinity`;
+     * `lo` must not exceed `hi`, and the length must equal the parameter count.
+     * Default: unbounded.
+     */
+    readonly bounds?: readonly (readonly [number, number])[];
+    /** Optimizer. Default: the fitter's choice (`'lm'` for `'l2'`, `'bfgs'` otherwise). */
+    readonly algorithm?: 'lm' | 'bfgs' | 'nelder-mead';
+    /**
+     * Start vector of every refit. Length must equal the parameter count and every
+     * value must be finite. Default: the tree's inherited vector (ones at the
+     * initial population).
+     */
+    readonly initial?: ArrayLike<number>;
 }
 /** One progress event; `status` is always `'fitted'`. */
 export interface SearchProgress {
@@ -101,7 +315,7 @@ export interface SearchProgress {
     readonly fittedParameters: Float64Array[];
     readonly selected?: ScoredCandidate<ScalarNode>;
 }
-export type ScalarSearchStopReason = 'max-evaluations' | 'max-candidates';
+export type ScalarSearchStopReason = 'max-evaluations' | 'max-candidates' | 'cancelled' | 'early-stop';
 /** Final value of the async generator returned by {@link searchScalars}. */
 export interface ScalarSearchResult {
     readonly front: ScoredCandidate<ScalarNode>[];
@@ -111,7 +325,21 @@ export interface ScalarSearchResult {
     readonly evaluations: number;
     readonly seed: number;
     readonly selected?: ScoredCandidate<ScalarNode>;
+    /**
+     * How often a seed or offspring kept its unsimplified shape because simplification
+     * threw (other than `ScalarBuildError`), failed the grammar or row-wise evaluation
+     * check, or hit a `RangeError` from a deep simplify. Zero when `simplify` is
+     * `'off'` or omitted.
+     */
+    readonly simplifyFallbacks: number;
 }
+/** @internal Exported for unit tests; not part of the package barrel. */
+export declare function simplifyCandidateForTest(node: ScalarNode, mode: ScalarSearchOptions['simplify'], recordFallback?: () => void): ScalarNode;
+/** @internal Exported for unit tests; not part of the package barrel. */
+export declare function hallFrontForTest(individuals: readonly EvaluatedIndividual[]): {
+    front: ScoredCandidate<ScalarNode>[];
+    fittedParameters: Float64Array[];
+};
 /** @internal One evaluated tree; exported for the unit tests, not the package barrel. */
 export interface EvaluatedIndividual {
     readonly node: ScalarNode;
@@ -168,9 +396,92 @@ export declare function migrateIslands(islands: Island[], fractionReplaced: numb
  * The generator yields one {@link SearchProgress} after the initial population
  * and one after every generation, and returns a {@link ScalarSearchResult}.
  * Evaluations never exceed `maxEvaluations`. `options.rng` is not advanced, so two
- * runs with the same inputs and seed agree bit for bit.
+ * runs with the same inputs and seed agree bit for bit. When `grammar.admit` is
+ * set it binds seeds and mutation offspring (`scalarGrammarAccepts`, then `admit`).
+ * A rejected child is a failed attempt; a rejected seed is skipped. `admit` must
+ * be a pure function of the node — a predicate that reads a clock or a random
+ * stream makes the run unreproducible. `admitMonotone` is left to enumeration.
+ * Ranking and refit share `loss` (`'l2'` by default) and optional `rowWeights`.
+ * `invalidRows` defaults to `'reject'` (`+Infinity` on any invalid row); `'penalize'`
+ * adds {@link INVALID_ROW_PENALTY} per positively weighted invalid row on top of the
+ * valid-row loss (absolute, not target-scaled). Under `'penalize'` the advisory refit
+ * still runs when every weighted row is invalid; refit acceptance uses the ranker on
+ * both sides. `complexityWeights` weighs the nodes of the complexity the hall, the
+ * truncation tie-break, and adaptive parsimony use; omitted, it is today's size.
+ * When set, weights are copied into a frozen snapshot before the first yield (plain
+ * data objects only; non-enumerable keys and accessors are rejected). Record keys
+ * use lowered call names (`ln` → `log`); unknown keys are ignored by
+ * `scalarComplexity`. `grammar.maxSize` counts raw nodes, not weighted complexity;
+ * `Math.round` on the sum can map distinct trees to one hall slot. The hall keeps one
+ * tree per canonical key at add time (best loss, then complexity, then first recorded);
+ * elitist truncation already keeps one tree per key in the population with the same
+ * loss-first order. Weights change reported complexity only, not which duplicate survives.
+ * `fit`
+ * forwards `restarts` (default 2), `maxIterations` (default 8), `bounds`,
+ * `algorithm`, and `initial` (default the inherited vector) to the fitter; a bad
+ * bound or length throws before the first yield. Omitted fields are today's call.
+ * `crossoverProbability` defaults to 0 (no coin). A positive probability draws
+ * the coin on the island stream and, on success, a second tournament parent.
+ * `simplify` defaults to `'off'` (no simplifier runs). `'constants'` folds
+ * numeric-only subtrees and `'algebraic'` runs the expression simplifier, once
+ * per seed and per bred offspring, before the grammar check and the score; a
+ * `ScalarBuildError`, `RangeError`, grammar rejection (including `admit`), or
+ * row-wise evaluation mismatch keeps the unsimplified tree. Enumerated trees are
+ * not simplified. Simplification draws no random numbers, but different accepted
+ * trees can change mutation outcomes, so a run with `simplify` on may diverge from
+ * `'off'`; two runs that share the same mode and seed still match. Progress event
+ * count stays budget-driven. `dimensions` (opt-in) checks the SI dimension of the
+ * tree that will be scored — after the grammar check, before the score — against
+ * `target`: a violation or an `inconsistent` solve scores `Infinity` (still an
+ * evaluation, never in the hall), an underdetermined solve is kept by default or
+ * rejected with `'reject'`, and the check draws no random numbers. `signal`
+ * (opt-in) is checked before the initial population and between generations, never
+ * mid-draw: already aborted before the first yield the result carries an empty
+ * front and `evaluations: 0`; aborted after a yield the last progress is returned
+ * as the result, both with `stopReason: 'cancelled'`. `earlyStop` (opt-in) ends
+ * the run with `stopReason: 'early-stop'` once the best finite hall loss has been
+ * `<= loss` for `generations` consecutive generations (hall after the generation,
+ * initial population included).
  *
  * @throws {RangeError} A malformed problem or option, or a grammar that admits no tree.
  */
 export declare function searchScalars(problem: ScalarSearchProblem, options: ScalarSearchOptions): AsyncGenerator<SearchProgress, ScalarSearchResult>;
+/**
+ * Problem input for {@link runScalarSearch}: like {@link ScalarSearchProblem},
+ * but `columns` may be a record keyed by variable name instead of the aligned
+ * array `searchScalars` requires.
+ */
+export interface ScalarSearchRunProblem extends Omit<ScalarSearchProblem, 'columns'> {
+    /**
+     * One column per variable. Either the aligned array `searchScalars` takes, or a
+     * record keyed by the names in `variables`; the wrapper reads a record in
+     * `variables` order to build that array. A name without an entry throws
+     * `RangeError`. A column whose length differs from `observed.length` throws
+     * `RangeError` from `searchScalars` as usual.
+     */
+    readonly columns: readonly Float64Array[] | Readonly<Record<string, Float64Array>>;
+}
+/**
+ * Options for {@link runScalarSearch}: {@link ScalarSearchOptions} with `rng`
+ * optional — exactly one of `seed` and `rng` must be set.
+ */
+export type ScalarSearchRunOptions = Omit<ScalarSearchOptions, 'rng'> & {
+    /** Seed for a fresh {@link createSeededRng}; required when `rng` is omitted. */
+    readonly seed?: number;
+    /** Caller-owned random stream; required when `seed` is omitted, never advanced. */
+    readonly rng?: SeededRng;
+};
+/**
+ * Consume {@link searchScalars} to its final {@link ScalarSearchResult} (SR-16).
+ * A thin wrapper: when `seed` is set and `rng` is omitted it builds
+ * {@link createSeededRng}(seed) and passes that; when both are set, or neither
+ * is, it throws `RangeError`. A `columns` record is read in `variables` order.
+ * It does not reimplement any search behavior, so every documented default and
+ * the seed-7 pin hold unchanged.
+ *
+ * @throws {RangeError} `seed` and `rng` are both set, neither is set, a variable
+ * has no entry in `columns`, `bestLossFactor` is non-finite, or any check
+ * {@link searchScalars} itself performs fails.
+ */
+export declare function runScalarSearch(problem: ScalarSearchRunProblem, options: ScalarSearchRunOptions): Promise<ScalarSearchResult>;
 //# sourceMappingURL=scalar-search.d.ts.map

package/dist/scalar-search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalar-search.d.ts","sourceRoot":"","sources":["../src/scalar-search.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"scalar-search.d.ts","sourceRoot":"","sources":["../src/scalar-search.ts"],"names":[],"mappings":"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"}

package/dist/signal/dtw.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Dynamic time warping with an optional Sakoe-Chiba band.
+ *
+ * @packageDocumentation
+ */
+type Vec = readonly number[] | Float64Array;
+/** Options for {@link dtw}. */
+export interface DtwOptions {
+    /**
+     * Sakoe-Chiba band half-width in samples. Widened automatically to at least
+     * |a.length - b.length|. Default: unconstrained.
+     */
+    window?: number;
+    /** Local cost between two samples (default `|x - y|`). */
+    dist?: (x: number, y: number) => number;
+}
+/** Result of {@link dtw}. */
+export interface DtwResult {
+    /** Accumulated cost of the optimal warping path. */
+    distance: number;
+    /** Optimal alignment as (i, j) index pairs from [0, 0] to [n-1, m-1]. */
+    path: Array<[number, number]>;
+}
+/**
+ * Dynamic time warping between two sequences.
+ *
+ * @example
+ * dtw([1, 2, 3], [1, 2, 2, 3]).distance; // 0
+ */
+export declare function dtw(a: Vec, b: Vec, opts?: DtwOptions): DtwResult;
+export {};
+//# sourceMappingURL=dtw.d.ts.map

package/dist/signal/dtw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dtw.d.ts","sourceRoot":"","sources":["../../src/signal/dtw.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAG5C,+BAA+B;AAC/B,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CACzC;AAED,6BAA6B;AAC7B,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,SAAS,CAsDhE"}

package/dist/signal/lomb-scargle.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Lomb-Scargle periodogram for unevenly sampled data (classic Scargle form with
+ * the tau time offset, as in scipy.signal.lombscargle).
+ *
+ * @packageDocumentation
+ */
+type Vec = readonly number[] | Float64Array;
+/** Options for {@link lombScargle}. */
+export interface LombScargleOptions {
+    /** Scale so that a pure sinusoid of unit amplitude peaks near 1 (default false). */
+    normalize?: boolean;
+    /** Subtract the mean of y before the transform (default false). */
+    precenter?: boolean;
+}
+/**
+ * Lomb-Scargle power at each angular frequency in `freqs` (rad per time unit).
+ *
+ * @param t - Sample times
+ * @param y - Sample values, same length as t
+ * @param freqs - Angular frequencies omega
+ * @returns Power per frequency (unnormalized: 0.5 * sum of squared projections)
+ */
+export declare function lombScargle(t: Vec, y: Vec, freqs: Vec, opts?: LombScargleOptions): number[];
+export {};
+//# sourceMappingURL=lomb-scargle.d.ts.map

package/dist/signal/lomb-scargle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lomb-scargle.d.ts","sourceRoot":"","sources":["../../src/signal/lomb-scargle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAG5C,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC,oFAAoF;IACpF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,mEAAmE;IACnE,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,kBAAkB,GAAG,MAAM,EAAE,CA0C3F"}

package/dist/signal/system-response.d.ts

@@ -0,0 +1,82 @@
+/**
+ * LTI system responses, transfer-function / state-space conversions, and
+ * simple IIR notch / peak designs (scipy.signal parity for the covered cases).
+ *
+ * Transfer-function coefficient arrays are highest-power first (scipy order).
+ *
+ * @packageDocumentation
+ */
+import type { ComplexNumber } from './fft.js';
+type Vec = readonly number[] | Float64Array;
+/** Continuous or discrete state-space realisation. */
+export interface StateSpace {
+    A: number[][];
+    B: number[][];
+    C: number[][];
+    D: number[][];
+}
+/** Discretisation method for {@link cont2discrete}. */
+export type DiscretizeMethod = 'zoh' | 'bilinear' | 'euler';
+/** Second-order-section filter coefficients. */
+export interface BiquadCoefficients {
+    b: number[];
+    a: number[];
+}
+/** Impulse response h[0..n-1] of the filter b / a. */
+export declare function impulseResponse(b: Vec, a: Vec, n: number): number[];
+/** Step response y[0..n-1] of the filter b / a. */
+export declare function stepResponse(b: Vec, a: Vec, n: number): number[];
+/**
+ * Transfer function to controllable canonical state space (SISO), as scipy.signal.tf2ss.
+ *
+ * @example
+ * tf2ss([1], [1, 3, 2]); // A = [[-3, -2], [1, 0]], B = [[1], [0]], C = [[0, 1]], D = [[0]]
+ */
+export declare function tf2ss(b: Vec, a: Vec): StateSpace;
+/**
+ * State space to transfer function (SISO), as scipy.signal.ss2tf.
+ * num is returned without leading zeros.
+ */
+export declare function ss2tf(A: number[][], B: number[][], C: number[][], D: number[][]): {
+    num: number[];
+    den: number[];
+};
+/**
+ * Convert a continuous state-space system to discrete time with sample period dt.
+ *
+ * - `zoh`: exact zero-order hold, via the exponential of [[A, B], [0, 0]] dt
+ * - `bilinear`: Tustin (scipy, alpha = 1/2), with M = (I - A dt/2)^-1:
+ *   Ad = M (I + A dt/2), Bd = M B dt, Cd = C M, Dd = D + C Bd / 2
+ * - `euler`: forward Euler, Ad = I + A dt, Bd = B dt
+ */
+export declare function cont2discrete(sys: StateSpace, dt: number, method?: DiscretizeMethod): StateSpace;
+/**
+ * Second-order IIR notch at normalised frequency w0 (x pi rad/sample), quality
+ * factor Q = w0 / bandwidth (scipy.signal.iirnotch convention: -3 dB bandwidth
+ * w0 pi / Q). Zero at w0, unity gain at DC.
+ */
+export declare function iirNotch(w0: number, Q: number): BiquadCoefficients;
+/**
+ * Second-order IIR peak (band-pass) at w0 (x pi rad/sample), unity gain at w0 and
+ * zero gain at DC and Nyquist (scipy.signal.iirpeak convention, Q = w0 / bandwidth).
+ */
+export declare function iirPeak(w0: number, Q: number): BiquadCoefficients;
+/**
+ * Transfer function to zeros, poles and gain (scipy.signal.tf2zpk). Zeros and
+ * poles are sorted by real then imaginary part.
+ */
+export declare function tf2zpk(b: Vec, a: Vec): {
+    z: ComplexNumber[];
+    p: ComplexNumber[];
+    k: number;
+};
+/**
+ * Cascade of second-order sections to a single transfer function. Each section
+ * is [b0, b1, b2, a0, a1, a2]; the result is not normalised by a0.
+ */
+export declare function sos2tf(sos: ReadonlyArray<readonly number[]>): {
+    b: number[];
+    a: number[];
+};
+export {};
+//# sourceMappingURL=system-response.d.ts.map

package/dist/signal/system-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-response.d.ts","sourceRoot":"","sources":["../../src/signal/system-response.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAG5C,sDAAsD;AACtD,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CACf;AAED,uDAAuD;AACvD,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,CAAC;AAE5D,gDAAgD;AAChD,MAAM,WAAW,kBAAkB;IACjC,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb;AAuFD,sDAAsD;AACtD,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAKnE;AAED,mDAAmD;AACnD,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAEhE;AAMD;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,UAAU,CAqBhD;AAyBD;;;GAGG;AACH,wBAAgB,KAAK,CACnB,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,CAAC,EAAE,MAAM,EAAE,EAAE,GACZ;IAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,CAWlC;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,UAAU,EACf,EAAE,EAAE,MAAM,EACV,MAAM,GAAE,gBAAwB,GAC/B,UAAU,CA0CZ;AAmBD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAQlE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAQjE;AAoDD;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG;IAAE,CAAC,EAAE,aAAa,EAAE,CAAC;IAAC,CAAC,EAAE,aAAa,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAM5F;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,aAAa,CAAC,SAAS,MAAM,EAAE,CAAC,GAAG;IAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAc1F"}

package/dist/signal/waveforms.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Test waveform generators (scipy.signal.waveforms parity).
+ *
+ * Phase offsets `phi` are in radians (scipy takes degrees for chirp/sweep_poly).
+ *
+ * @packageDocumentation
+ */
+type Vec = readonly number[] | Float64Array;
+/** Frequency sweep method for {@link chirp}. */
+export type ChirpMethod = 'linear' | 'quadratic' | 'logarithmic' | 'hyperbolic';
+/** Options for {@link chirp}. */
+export interface ChirpOptions {
+    /** Sweep law (default `'linear'`). */
+    method?: ChirpMethod;
+    /** Phase offset in radians (default 0). */
+    phi?: number;
+}
+/**
+ * Cosine chirp sweeping from f0 at t = 0 to f1 at t = t1 (frequencies in Hz).
+ *
+ * @example
+ * chirp([0], 1, 1, 10); // [1]
+ */
+export declare function chirp(t: Vec, f0: number, t1: number, f1: number, opts?: ChirpOptions): number[];
+/**
+ * Square wave: +1 while frac(t / 2 pi) < duty, otherwise -1.
+ */
+export declare function squareWave(t: Vec, duty?: number): number[];
+/**
+ * Sawtooth wave: -1 at phase 0 rising to +1 at phase 2 pi * width, then falling
+ * back. `width = 1` is a rising ramp; `width = 0.5` is a triangle.
+ */
+export declare function sawtooth(t: Vec, width?: number): number[];
+/**
+ * Gaussian-modulated cosine pulse.
+ *
+ * @param fc - Centre frequency (Hz)
+ * @param bw - Fractional bandwidth (default 0.5)
+ * @param bwr - Reference level in dB for the bandwidth (default -6)
+ */
+export declare function gaussPulse(t: Vec, fc: number, bw?: number, bwr?: number): number[];
+/**
+ * Discrete unit impulse of length n. `idx` defaults to 0, `'mid'` is floor(n / 2).
+ */
+export declare function unitImpulse(n: number, idx?: number | 'mid'): number[];
+/**
+ * Cosine with a polynomial instantaneous frequency f(t) = sum_k c_k t^(p-k) Hz.
+ * `polyCoeffs` are highest-order first (numpy poly1d order).
+ */
+export declare function sweepPoly(t: Vec, polyCoeffs: readonly number[], phi?: number): number[];
+export {};
+//# sourceMappingURL=waveforms.d.ts.map

package/dist/signal/waveforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waveforms.d.ts","sourceRoot":"","sources":["../../src/signal/waveforms.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAI5C,gDAAgD;AAChD,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,aAAa,GAAG,YAAY,CAAC;AAEhF,iCAAiC;AACjC,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,CAM/F;AAuCD;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAE,MAAY,GAAG,MAAM,EAAE,CAM/D;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,EAAE,CAO5D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,GAAE,MAAY,EAAE,GAAG,GAAE,MAAW,GAAG,MAAM,EAAE,CAI3F;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,GAAG,KAAS,GAAG,MAAM,EAAE,CASxE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,GAAE,MAAU,GAAG,MAAM,EAAE,CAW1F"}